[TYPES/announce] ICFP 2024: Call for Tutorials

[ICFP Publicity]

[ The Types Forum (announcements only),
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

ICFP 2024

CALL FOR TUTORIAL, PANEL, AND DISCUSSION PROPOSALS

29th ACM SIGPLAN International Conference on Functional Programming

https://urldefense.com/v3/__https://icfp24.sigplan.org/track/icfp-2024-tutorials__;!!IBzWLUs!SIsXw5L9tSR6GOAev8CJ3rrT544VjWTOwMk7AnVefB1kWvMr86hMjly4wP1IZi9vLyzs8EUYhRQ_pnDaPgtn2SSVsSI7enVjDjZUINLyr1g$
 


September 2 - 7, 2024

Milan, Italy

https://urldefense.com/v3/__https://icfp24.sigplan.org/__;!!IBzWLUs!SIsXw5L9tSR6GOAev8CJ3rrT544VjWTOwMk7AnVefB1kWvMr86hMjly4wP1IZi9vLyzs8EUYhRQ_pnDaPgtn2SSVsSI7enVjDjZUZ1xCJ5I$
  



The 29th ACM SIGPLAN International Conference on Functional

Programming will be held in Milan, Italy on September 2 - 7,

2024, with the option of virtual participation. ICFP provides a forum

for researchers and developers to hear about the latest work on the

design, implementations, principles, and uses of functional

programming.

Proposals are invited for tutorials, lasting approximately 3 hours each,

to be presented during ICFP and its co-located workshops and other events.

The tutorials may target an audience who is interested in commercial uses

of functional programming, but we also welcome tutorials whose primary

audience is researchers rather than practitioners. Tutorials may focus
either

on a concrete technology or on a theoretical or mathematical tool. Ideally,

tutorials will have a concrete result, such as "Learn to do X with Y"

rather than "Learn language Y".

Just like last year, following the success of the #ShutDownPL event, we are
also

inviting proposals for panels and discussions on topics of broader interest

to the PL community.

Tutorials, panels, and discussions may occur before or after ICFP,

co-located with the associated workshops, on September 2 or September 6-7.


--

Submission details

Deadline for submission: May 24, 2024

Notification of acceptance: May 27, 2024

Prospective organizers of tutorials are invited to submit a completed

tutorial proposal form in plain text format to the ICFP 2024 workshop

co-chairs (Yannick Forster and Chandrakana Nandi), via email to

yannick.fors...@inria.fr and chan...@certora.com

by May 24rd, 2024. Please note that this is a firm deadline.

The proposal form is available at:

https://urldefense.com/v3/__http://www.icfpconference.org/icfp2024-files/icfp24-panel-form.txt__;!!IBzWLUs!SIsXw5L9tSR6GOAev8CJ3rrT544VjWTOwMk7AnVefB1kWvMr86hMjly4wP1IZi9vLyzs8EUYhRQ_pnDaPgtn2SSVsSI7enVjDjZUyac0NpI$
 


https://urldefense.com/v3/__http://www.icfpconference.org/icfp2024-files/icfp24-tutorials-form.txt__;!!IBzWLUs!SIsXw5L9tSR6GOAev8CJ3rrT544VjWTOwMk7AnVefB1kWvMr86hMjly4wP1IZi9vLyzs8EUYhRQ_pnDaPgtn2SSVsSI7enVjDjZU0GvsZP4$
 


--

Selection committee

The proposals will be evaluated by a committee comprising the

following members of the ICFP 2024 organizing committee, together

with the members of the SIGPLAN executive committee.

Workshop Co-Chair: Yannick Forster (Inria Nantes)

Workshop Co-Chair: Chandrakana Nandi (Certora Inc.)

General Chair: Marco Gaboardi (Boston University)

Program Chair: Brigitte Pientka (McGill University)

--

Further information

Any queries should be addressed to the workshop co-chairs (Yannick Forster
and Chandrakana Nandi), via email to

yannick.fors...@inria.fr and chan...@certora.com

[TYPES/announce] ICFP 2024: Second Call for Papers

[ICFP Publicity]

[ The Types Forum (announcements only),
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

 PACMPL Volume 7, Issue ICFP 2024

   Call for Papers

   Accepted papers to be invited for presentation at

The 29th ACM SIGPLAN International Conference on Functional Programming

  Milan, Italy

### Important dates

(All dates are in 2023 at 11.59pm Anywhere on Earth.)

Paper Submission -- Wed 28 Feb 2024  (AOE)
Paper Author Response -- Mon 29 Apr 12:00 - Wed 1 May 12:00 2024
Paper Notification --Mon 20 May 2024


### NEW THIS YEAR
---

* Full double blind reviewing

### Scope
---

PACMPL issue ICFP 2024 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. Topics of
interest include (but are not limited to):

* Language Design: concurrency, parallelism, and distribution; modularity;
components and composition; meta-programming; macros; pattern matching;
type systems; type inference; dependent types; effect types; gradual types;
refinement types; session types; interoperability; domain-specific
languages; imperative programming; object-oriented programming; logic
programming; probabilistic programming; reactive programming; generic
programming; bidirectional programming.

* Implementation: abstract machines; virtual machines; interpretation;
compilation; compile-time and run-time optimisation; garbage collection and
memory management; runtime systems; 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; build systems; program synthesis.

* Foundations: formal semantics; lambda calculus; program equivalence;
rewriting; type theory; logic; category theory; computational effects;
continuations; control; state; names and binding; program verification.

* Analysis and Transformation: control flow; data flow; abstract
interpretation; partial evaluation; program calculation.

* Applications: symbolic computing; formal-methods tools; artificial
intelligence; systems programming; distributed systems and web programming;
hardware design; databases; scientific and numerical computing; graphical
user interfaces; graphics and multimedia; GPU programming; scripting;
system administration; security.

* Education: teaching introductory programming; mathematical proof; algebra.

Submissions will be evaluated according to their relevance, correctness,
significance, originality, and clarity. Each submission should explain its
contributions in both general and technical terms, clearly identifying what
has been accomplished, explaining why it is significant, and comparing it
with previous work. The technical content should be accessible to a broad
audience.

PACMPL issue ICFP 2024 also welcomes submissions in two separate categories
— Functional Pearls and Experience Reports — that must be marked as such
when submitted and that need not report original research results. Detailed
guidelines on both categories are given at the end of this call.

In an effort to achieve a balanced, diverse program, each author may be
listed as a (co)author on a maximum of four submissions. Submissions from
underrepresented groups are encouraged. Authors who require financial
support to attend the conference can apply for PAC funding (
https://urldefense.com/v3/__http://www.sigplan.org/PAC/__;!!IBzWLUs!SBXe5Avn8LSONT-Z7MRWFrZu_KWigCAUsRyCWRqu8hOawjnULYu5jM78MFh0ZnLLDDJCrMLf7rMU6IMDeHIThrl2-X32W5d7JIAzHvYXKEw$
 ).

The General Chair and PC Chair may not submit papers. PC members (other
than the PC Chair) may submit papers.

Please contact the Program Chair if you have questions or are concerned
about the appropriateness of a topic.

### Full Double-Blind Reviewing Process

ICFP 2024 will use a full double-blind reviewing process (similar to the
one used for POPL 2024 but different from the lightweight double-blind
process used in previous years). This means that identities of authors will
not be made visible to reviewers until after conditional-acceptance
decisions have been made, and then only for the conditionally-accepted
papers. The use of full double-blind reviewing has several consequences for
authors.

* Submissions: Authors must omit their names and institutions from their
paper submissions. In addition, references to authors’ own prior work
should be in the third person (e.g., not “We build on our previous work …”
but rather “We 

[TYPES/announce] ICFP 2024: Call for Workshops and Co-Located Events

[ICFP Publicity]

[ The Types Forum (announcements only),
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

CALL FOR WORKSHOP AND CO-LOCATED EVENT PROPOSALS
ICFP 2024
29th ACM SIGPLAN International Conference on Functional Programming

September 2 - 7, 2024
Milan, Italy
https://urldefense.com/v3/__https://icfp24.sigplan.org/__;!!IBzWLUs!W9rhYkbK2G3cU3u8ZZhmX2HHyYEgZVY1qQsDtpmDa0Luzo4bRZWqSRnJdO-3N76K993S2O-C0yhfmXclLVqXa2vekeyI2AOLaXk8_1D0Oco$
 

The 29th ACM SIGPLAN International Conference on Functional
Programming will be held in Milan, Italy on September 2 - 7,
2024, with the option of virtual participation. ICFP provides a forum
for researchers and developers to hear about the latest work on the
design, implementations, principles, and uses of functional
programming.

Proposals are invited for workshops (and other co-located events,
such as symposiums) to be affiliated with ICFP 2024 and sponsored by
SIGPLAN. These events should be less formal and more focused than
ICFP itself, include sessions that enable interaction among the
attendees, and foster the exchange of new ideas. The preference is
for one-day events, but other schedules can also be considered.

The workshops are scheduled to occur on September 2nd (the day before
ICFP) and September 6-7th (the two days after ICFP).

A separate call for Call for Tutorial, Panel, and Discussion Proposals is
going to be circulated later.

--

Submission details
Deadline for submission: January 11, 2024
Notification of acceptance: January 19, 2024

Prospective organizers of workshops or other co-located events are
invited to submit a completed workshop proposal form in plain text
format to the ICFP 2024 workshop co-chairs (Chandrakana Nandi
and Yannick Forster) via email to

chan...@certora.com
yannick.fors...@inria.fr

by January 11, 2024. (For proposals of co-located events other than
workshops, please fill in the workshop proposal form and just leave
blank any sections that do not apply.) Please note that this is a
firm deadline.

Organizers will be notified whether their event proposal is accepted
by January 19, 2024, and if successful, depending on the event, they
will be asked to produce a final report after the event has taken
place that is suitable for publication in SIGPLAN Notices.

The proposal form is available at:

https://urldefense.com/v3/__http://www.icfpconference.org/icfp2024-files/icfp24-workshops-form.txt.docx__;!!IBzWLUs!W9rhYkbK2G3cU3u8ZZhmX2HHyYEgZVY1qQsDtpmDa0Luzo4bRZWqSRnJdO-3N76K993S2O-C0yhfmXclLVqXa2vekeyI2AOLaXk84PRnksA$
 

PC Template:

https://urldefense.com/v3/__http://www.icfpconference.org/icfp2024-files/pc-template.xlsx__;!!IBzWLUs!W9rhYkbK2G3cU3u8ZZhmX2HHyYEgZVY1qQsDtpmDa0Luzo4bRZWqSRnJdO-3N76K993S2O-C0yhfmXclLVqXa2vekeyI2AOLaXk8K9Sambk$
 

Further information about SIGPLAN sponsorship is available at:

https://urldefense.com/v3/__http://www.sigplan.org/Resources/Proposals/Sponsored/__;!!IBzWLUs!W9rhYkbK2G3cU3u8ZZhmX2HHyYEgZVY1qQsDtpmDa0Luzo4bRZWqSRnJdO-3N76K993S2O-C0yhfmXclLVqXa2vekeyI2AOLaXk8azGJYDk$
 

--

Selection committee

The proposals will be evaluated by a committee comprising the
following members of the ICFP 2024 organizing committee, together
with the members of the SIGPLAN executive committee.

Workshop Co-Chair: Chandrakana Nandi (Certora)
Workshop Co-Chair: Yannick Forster (Inria)
General Chair: Marco Gaboardi (Boston University)
Program Chair: Brigitte Pientka (McGill University)


--

Further information

Any queries should be addressed to the workshop co-chairs
(Chandrakana Nandi and Yannick Forster), via email to
chan...@certora.com end yannick.fors...@inria.fr

[TYPES/announce] ICFP 2024: Call for Papers

[ICFP Publicity]

[ The Types Forum (announcements only),
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

 PACMPL Volume 7, Issue ICFP 2024

   Call for Papers

   Accepted papers to be invited for presentation at

The 29th ACM SIGPLAN International Conference on Functional Programming

  Milan, Italy

### Important dates

(All dates are in 2023 at 11.59pm Anywhere on Earth.)

Paper Submission -- Wed 28 Feb 2024  (AOE)
Paper Author Response -- Mon 29 Apr 12:00 - Wed 1 May 12:00 2024
Paper Notification --Mon 20 May 2024


### NEW THIS YEAR
---

* Full double blind reviewing

### Scope
---

PACMPL issue ICFP 2024 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. Topics of
interest include (but are not limited to):

* Language Design: concurrency, parallelism, and distribution; modularity;
components and composition; meta-programming; macros; pattern matching;
type systems; type inference; dependent types; effect types; gradual types;
refinement types; session types; interoperability; domain-specific
languages; imperative programming; object-oriented programming; logic
programming; probabilistic programming; reactive programming; generic
programming; bidirectional programming.

* Implementation: abstract machines; virtual machines; interpretation;
compilation; compile-time and run-time optimisation; garbage collection and
memory management; runtime systems; 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; build systems; program synthesis.

* Foundations: formal semantics; lambda calculus; program equivalence;
rewriting; type theory; logic; category theory; computational effects;
continuations; control; state; names and binding; program verification.

* Analysis and Transformation: control flow; data flow; abstract
interpretation; partial evaluation; program calculation.

* Applications: symbolic computing; formal-methods tools; artificial
intelligence; systems programming; distributed systems and web programming;
hardware design; databases; scientific and numerical computing; graphical
user interfaces; graphics and multimedia; GPU programming; scripting;
system administration; security.

* Education: teaching introductory programming; mathematical proof; algebra.

Submissions will be evaluated according to their relevance, correctness,
significance, originality, and clarity. Each submission should explain its
contributions in both general and technical terms, clearly identifying what
has been accomplished, explaining why it is significant, and comparing it
with previous work. The technical content should be accessible to a broad
audience.

PACMPL issue ICFP 2024 also welcomes submissions in two separate categories
— Functional Pearls and Experience Reports — that must be marked as such
when submitted and that need not report original research results. Detailed
guidelines on both categories are given at the end of this call.

In an effort to achieve a balanced, diverse program, each author may be
listed as a (co)author on a maximum of four submissions. Submissions from
underrepresented groups are encouraged. Authors who require financial
support to attend the conference can apply for PAC funding (
https://urldefense.com/v3/__http://www.sigplan.org/PAC/__;!!IBzWLUs!TA6exFGeBGGJWiNbpbbvsLmfsZwoc5ukb01eZFZgKUeY3QrHSEgl9zZtFa-iqwSxslVLIe6AZNN4IdHWazJ32jhdVOz6qMH-ds8G2ANxqRg$
 ).

The General Chair and PC Chair may not submit papers. PC members (other
than the PC Chair) may submit papers.

Please contact the Program Chair if you have questions or are concerned
about the appropriateness of a topic.

### Full Double-Blind Reviewing Process

ICFP 2024 will use a full double-blind reviewing process (similar to the
one used for POPL 2024 but different from the lightweight double-blind
process used in previous years). This means that identities of authors will
not be made visible to reviewers until after conditional-acceptance
decisions have been made, and then only for the conditionally-accepted
papers. The use of full double-blind reviewing has several consequences for
authors.

* Submissions: Authors must omit their names and institutions from their
paper submissions. In addition, references to authors’ own prior work
should be in the third person (e.g., not “We build on our previous work …”
but rather “We 

[TYPES/announce] PADL'24: Last Call for Papers

[ICFP Publicity]

[ The Types Forum (announcements only),
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

==
Call for Papers

  26th International Symposium on Practical Aspects of Declarative Languages
  (PADL 2024)

  
https://urldefense.com/v3/__https://popl24.sigplan.org/home/PADL-2024__;!!IBzWLUs!QoYtuEjpviVEj4QFtyDz1cWhMR1x9JR0RT8vDjfxVB6he77rpR5Q9XMGSByc8utJyl70FKkLzIhfQTiX0_wGwO7VO7DqfPUJ15sw0vAqqzQ$
 

 London, United Kingdom, January 15-16, 2024

   Co-located with ACM POPL 2024
==


Conference Description
--

Declarative languages comprise several well-established classes of
formalisms, namely, functional, logic, and constraint programming.
Such formalisms enjoy both sound theoretical bases and the
availability of attractive frameworks for application development.
Indeed, they have been already successfully applied to many different
real-world situations, ranging from database management to active
networks to software engineering to decision support systems.


New developments in theory and implementation fostered applications in
new areas. At the same time, applications of declarative languages to
novel and challenging problems raise many interesting research issues,
including designing for scalability, language extensions for
application deployment, and programming environments. Thus,
applications drive the progress in the theory and implementation of
declarative systems, and benefit from this progress as well.


PADL is a well-established forum for researchers and practitioners to
present original work emphasizing novel applications and
implementation techniques for all forms of declarative programming,
including functional and logic programming, database and constraint
programming, and theorem proving.


Topics of interest include, but are not limited to:


- Innovative applications of declarative languages
- Declarative domain-specific languages and applications
- Practical applications of theoretical results
- New language developments and their impact on applications
- Declarative languages and software engineering
- Evaluation of implementation techniques on practical applications
- Practical experiences and industrial applications
- Novel uses of declarative languages in the classroom
- Practical extensions such as constraint-based, probabilistic,
  and reactive languages


PADL 2024 especially welcomes new ideas and approaches related to
applications, design and implementation of declarative languages going
beyond the scope of the past PADL symposia, for example, advanced
database languages and contract languages, as well as verification and
theorem proving methods that rely on declarative languages.


Submissions
---

PADL 2024 welcomes three kinds of submission:

* Technical papers (max. 15 pages):
  Technical papers must describe original, previously unpublished
  research results.

* Application papers (max. 8 pages):
  Application papers are a mechanism to present important practical
  applications of declarative languages that occur in industry or in
  areas of research other than Computer Science. Application papers
  are expected to describe complex and/or real-world applications that
  rely on an innovative use of declarative languages. Application
  descriptions, engineering solutions and real-world experiences (both
  positive and negative) are solicited.

* Extended abstracts (max. 3 pages):
  Describing new ideas, a new perspective on already published work,
  or work-in-progress that is not yet ready for a full
  publication. Extended abstracts will be posted on the symposium
  website but will not be published in the formal proceedings.

All page limits exclude references. Submissions must be written in English
and formatted according to the standard Springer LNCS style, see
https://urldefense.com/v3/__https://www.springer.com/gp/computer-science/lncs/conference-proceedings-guidelines__;!!IBzWLUs!QoYtuEjpviVEj4QFtyDz1cWhMR1x9JR0RT8vDjfxVB6he77rpR5Q9XMGSByc8utJyl70FKkLzIhfQTiX0_wGwO7VO7DqfPUJ15sweBccPSw$
 

The review process of PADL 2024 is *double-anonymous*. In your submission,
please, omit your names and institutions; refer to your prior work in the
third person, just as you refer to prior work by others; do not include
acknowledgements that might identify you.

Page numbers (and, if possible, line numbers) should appear on the
manuscript to help the reviewers in writing their reports. So, for
LaTeX, we recommend that authors use:

 \pagestyle{plain}
 \usepackage{lineno}
 \linenumbers

The conference proceedings of PADL 2024 will be published by
Springer-Verlag in the Lecture Notes in Computer Science series.
Work that already appeared in unpublished or informally published
workshop proceedings may be 

[TYPES/announce] PADL 2024: Call for Papers

[ICFP Publicity]

[ The Types Forum (announcements only),
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

==
Call for Papers

  26th International Symposium on Practical Aspects of Declarative Languages
  (PADL 2024)

  
https://urldefense.com/v3/__https://popl24.sigplan.org/home/PADL-2024__;!!IBzWLUs!TCODq6gqYNrAObnGlWwOUMtOE6fxG57q4WJGS-EyvST_fTWC0mpRiNNx4c6v0SOnC94cpq21EjKwKjkEXDOuVlFDxX1S8e5WoCVnqKh6jM8$
 

 London, United Kingdom, January 15-16, 2024

   Co-located with ACM POPL 2024
==


Conference Description
--

Declarative languages comprise several well-established classes of
formalisms, namely, functional, logic, and constraint programming.
Such formalisms enjoy both sound theoretical bases and the
availability of attractive frameworks for application development.
Indeed, they have been already successfully applied to many different
real-world situations, ranging from database management to active
networks to software engineering to decision support systems.


New developments in theory and implementation fostered applications in
new areas. At the same time, applications of declarative languages to
novel and challenging problems raise many interesting research issues,
including designing for scalability, language extensions for
application deployment, and programming environments. Thus,
applications drive the progress in the theory and implementation of
declarative systems, and benefit from this progress as well.


PADL is a well-established forum for researchers and practitioners to
present original work emphasizing novel applications and
implementation techniques for all forms of declarative programming,
including functional and logic programming, database and constraint
programming, and theorem proving.


Topics of interest include, but are not limited to:


- Innovative applications of declarative languages
- Declarative domain-specific languages and applications
- Practical applications of theoretical results
- New language developments and their impact on applications
- Declarative languages and software engineering
- Evaluation of implementation techniques on practical applications
- Practical experiences and industrial applications
- Novel uses of declarative languages in the classroom
- Practical extensions such as constraint-based, probabilistic,
  and reactive languages


PADL 2024 especially welcomes new ideas and approaches related to
applications, design and implementation of declarative languages going
beyond the scope of the past PADL symposia, for example, advanced
database languages and contract languages, as well as verification and
theorem proving methods that rely on declarative languages.


Submissions
---

PADL 2024 welcomes three kinds of submission:

* Technical papers (max. 15 pages):
  Technical papers must describe original, previously unpublished
  research results.

* Application papers (max. 8 pages):
  Application papers are a mechanism to present important practical
  applications of declarative languages that occur in industry or in
  areas of research other than Computer Science. Application papers
  are expected to describe complex and/or real-world applications that
  rely on an innovative use of declarative languages. Application
  descriptions, engineering solutions and real-world experiences (both
  positive and negative) are solicited.

* Extended abstracts (max. 3 pages):
  Describing new ideas, a new perspective on already published work,
  or work-in-progress that is not yet ready for a full
  publication. Extended abstracts will be posted on the symposium
  website but will not be published in the formal proceedings.

All page limits exclude references. Submissions must be written in English
and formatted according to the standard Springer LNCS style, see
https://urldefense.com/v3/__https://www.springer.com/gp/computer-science/lncs/conference-proceedings-guidelines__;!!IBzWLUs!TCODq6gqYNrAObnGlWwOUMtOE6fxG57q4WJGS-EyvST_fTWC0mpRiNNx4c6v0SOnC94cpq21EjKwKjkEXDOuVlFDxX1S8e5WoCVn9jSmvws$
 

Page numbers (and, if possible, line numbers) should appear on the
manuscript to help the reviewers in writing their reports. So, for
LaTeX, we recommend that authors use:

 \pagestyle{plain}
 \usepackage{lineno}
 \linenumbers

The conference proceedings of PADL 2024 will be published by
Springer-Verlag in the Lecture Notes in Computer Science series.
Work that already appeared in unpublished or informally published
workshops proceedings may be submitted but the authors should notify
the program chairs where it has previously appeared.

Papers should be submitted electronically at

[TYPES/announce] ICFP 2023: Call for Participation

[ICFP Publicity]

[ The Types Forum (announcements only),
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

=
Call for Participation

The 28th ACM SIGPLAN International Conference
  on Functional Programming (ICFP 2023) and
  affiliated events

  
https://urldefense.com/v3/__https://icfp23.sigplan.org__;!!IBzWLUs!RGM3iQPSzIqv75jSAlyCIZCHdEM0tKQfhv-OPO5eXTUwbTCkyUTpPM-kS0dQXDXx5kvwRnNsoFHjRr62BGYUyWghTsb0X1qgu7KkgHjmD5Q$
 
 Seattle, USA; Sep 4-9, 2023
=

ICFP is a celebration of the art and science of functional
programming, providing a forum for researchers and developers to
engage on a variety of topics, from foundations to features, and from
abstraction to application.

You are invited to participate in a full week dedicated to functional
programming, featuring the ICFP main conference as well as several
other related events.

 * Accepted Papers:
   
https://urldefense.com/v3/__https://icfp23.sigplan.org/track/icfp-2023-papers*event-overview__;Iw!!IBzWLUs!RGM3iQPSzIqv75jSAlyCIZCHdEM0tKQfhv-OPO5eXTUwbTCkyUTpPM-kS0dQXDXx5kvwRnNsoFHjRr62BGYUyWghTsb0X1qgu7KkXkFXDgs$
 

 * Registration:
   
https://urldefense.com/v3/__https://icfp23.sigplan.org/attending/registration__;!!IBzWLUs!RGM3iQPSzIqv75jSAlyCIZCHdEM0tKQfhv-OPO5eXTUwbTCkyUTpPM-kS0dQXDXx5kvwRnNsoFHjRr62BGYUyWghTsb0X1qgu7KkAKI9AD4$
 
   The early-bird deadline is August 5, 2023

 * Hotel: The Westin Seattle
   
https://urldefense.com/v3/__https://icfp23.sigplan.org/venue/icfp-2023-venue__;!!IBzWLUs!RGM3iQPSzIqv75jSAlyCIZCHdEM0tKQfhv-OPO5eXTUwbTCkyUTpPM-kS0dQXDXx5kvwRnNsoFHjRr62BGYUyWghTsb0X1qgu7Kk2-tcBm4$
 
   Conference hotel reservation cutoff: August 11, 2023

There are several events affiliated with ICFP:

 September 4
   Erlang
 - 
https://urldefense.com/v3/__https://icfp23.sigplan.org/home/erlang-2023__;!!IBzWLUs!RGM3iQPSzIqv75jSAlyCIZCHdEM0tKQfhv-OPO5eXTUwbTCkyUTpPM-kS0dQXDXx5kvwRnNsoFHjRr62BGYUyWghTsb0X1qgu7KklShRx1I$
 
   FHPN
 - 
https://urldefense.com/v3/__https://icfp23.sigplan.org/home/FHPNC-2023__;!!IBzWLUs!RGM3iQPSzIqv75jSAlyCIZCHdEM0tKQfhv-OPO5eXTUwbTCkyUTpPM-kS0dQXDXx5kvwRnNsoFHjRr62BGYUyWghTsb0X1qgu7KkEm-MgXY$
 
   HIW
 - 
https://urldefense.com/v3/__https://icfp23.sigplan.org/home/hiw-2023__;!!IBzWLUs!RGM3iQPSzIqv75jSAlyCIZCHdEM0tKQfhv-OPO5eXTUwbTCkyUTpPM-kS0dQXDXx5kvwRnNsoFHjRr62BGYUyWghTsb0X1qgu7KkiXp52jA$
 
   HOPE
 - 
https://urldefense.com/v3/__https://icfp23.sigplan.org/home/hope-2023__;!!IBzWLUs!RGM3iQPSzIqv75jSAlyCIZCHdEM0tKQfhv-OPO5eXTUwbTCkyUTpPM-kS0dQXDXx5kvwRnNsoFHjRr62BGYUyWghTsb0X1qgu7KkD9KSk7w$
 
   PLMW
 - 
https://urldefense.com/v3/__https://icfp23.sigplan.org/track/plmw-icfp-2023__;!!IBzWLUs!RGM3iQPSzIqv75jSAlyCIZCHdEM0tKQfhv-OPO5eXTUwbTCkyUTpPM-kS0dQXDXx5kvwRnNsoFHjRr62BGYUyWghTsb0X1qgu7KkwPxlhmA$
 
   TyDe
 - 
https://urldefense.com/v3/__https://icfp23.sigplan.org/home/TyDe-2023__;!!IBzWLUs!RGM3iQPSzIqv75jSAlyCIZCHdEM0tKQfhv-OPO5eXTUwbTCkyUTpPM-kS0dQXDXx5kvwRnNsoFHjRr62BGYUyWghTsb0X1qgu7Kkkrv--0I$
 

 September 5-7
   ICFP - Main conference

 September 8
   Haskell
 - 
https://urldefense.com/v3/__https://icfp23.sigplan.org/home/haskellsymp-2023__;!!IBzWLUs!RGM3iQPSzIqv75jSAlyCIZCHdEM0tKQfhv-OPO5eXTUwbTCkyUTpPM-kS0dQXDXx5kvwRnNsoFHjRr62BGYUyWghTsb0X1qgu7KkUniOm9s$
 
   FARM
 - 
https://urldefense.com/v3/__https://icfp23.sigplan.org/home/farm-2023__;!!IBzWLUs!RGM3iQPSzIqv75jSAlyCIZCHdEM0tKQfhv-OPO5eXTUwbTCkyUTpPM-kS0dQXDXx5kvwRnNsoFHjRr62BGYUyWghTsb0X1qgu7KkxwezGHg$
 
   FUNARCH
 - 
https://urldefense.com/v3/__https://icfp23.sigplan.org/home/FUNARCH-2023__;!!IBzWLUs!RGM3iQPSzIqv75jSAlyCIZCHdEM0tKQfhv-OPO5eXTUwbTCkyUTpPM-kS0dQXDXx5kvwRnNsoFHjRr62BGYUyWghTsb0X1qgu7Kk6iRPL90$
 
   ML
 - 
https://urldefense.com/v3/__https://icfp23.sigplan.org/home/mlworkshop-2023__;!!IBzWLUs!RGM3iQPSzIqv75jSAlyCIZCHdEM0tKQfhv-OPO5eXTUwbTCkyUTpPM-kS0dQXDXx5kvwRnNsoFHjRr62BGYUyWghTsb0X1qgu7KkN1VYmn4$
 
   miniKanren
 - 
https://urldefense.com/v3/__https://icfp23.sigplan.org/home/minikanren-2023__;!!IBzWLUs!RGM3iQPSzIqv75jSAlyCIZCHdEM0tKQfhv-OPO5eXTUwbTCkyUTpPM-kS0dQXDXx5kvwRnNsoFHjRr62BGYUyWghTsb0X1qgu7Kkj5bKOKY$
 
   Tutorial: Vehicle, A Specification Language for Neural Network Properties
   Tutorial: Porting Lwt applications to OCaml 5 and Eio

 September 9
   Haskell
 - 
https://urldefense.com/v3/__https://icfp23.sigplan.org/home/haskellsymp-2023__;!!IBzWLUs!RGM3iQPSzIqv75jSAlyCIZCHdEM0tKQfhv-OPO5eXTUwbTCkyUTpPM-kS0dQXDXx5kvwRnNsoFHjRr62BGYUyWghTsb0X1qgu7KkUniOm9s$
 
   Scheme
 - 
https://urldefense.com/v3/__https://icfp23.sigplan.org/home/scheme-2023__;!!IBzWLUs!RGM3iQPSzIqv75jSAlyCIZCHdEM0tKQfhv-OPO5eXTUwbTCkyUTpPM-kS0dQXDXx5kvwRnNsoFHjRr62BGYUyWghTsb0X1qgu7KkArJh9fI$
 
   OCaml
 - 

[TYPES/announce] ICFP 2023: Call for Volunteers (Deadline: 30 June!)

[ICFP Publicity]

[ The Types Forum (announcements only),
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

ICFP 2023
CALL FOR VOLUNTEERS
28th ACM SIGPLAN International Conference on Functional Programming

https://urldefense.com/v3/__https://icfp23.sigplan.org/track/icfp-2023-volunteers__;!!IBzWLUs!WcCkdepPhhXD11Cs7DxUFXnP1L29tct4cGmbIRLfHGmcJlvQBBkW6XJ-Z2FlUhX-fCizmrbdhLiJJEnryvhYs477rIqxE7FNawJcc5m4hkk$
 

Sign up to be a Volunteer and help us make ICFP 2023 a unique
experience for all attendants!

ICFP 2023 is pleased to offer a number of opportunities for
volunteers, who are vital to the efficient operation and continued
success of the conference each year. The volunteer program is a chance
for people from around the world to participate in the conferences
whilst assisting us in preparing and running the event.

The Volunteer Program helps more people attend the ICFP conference by
covering conference fees, including access to the banquet (but not
travel or lodging expenses) in exchange for a fixed number of work
hours (usually from 12 to 15) helping with the conference
organization.

## How to apply

Please apply using this form 
(https://urldefense.com/v3/__https://forms.gle/27pzbztJq5PVCZeW9__;!!IBzWLUs!WcCkdepPhhXD11Cs7DxUFXnP1L29tct4cGmbIRLfHGmcJlvQBBkW6XJ-Z2FlUhX-fCizmrbdhLiJJEnryvhYs477rIqxE7FNawJc2zIr_LQ$
 ).
The deadline is June 30th

## Eligibility

Everyone is welcome to apply. Priority is given to junior members of
our community, e.g. full- or part-time students of computer science
and related fields.

## Expectation

Applicants must be available for at least four (4) full days between
September 4th and September 9th, 2023, and will be expected to provide
a total of 12-15 hours of volunteering work in that time.

The skills, talents, and dedication of our Volunteers contribute to
the overall quality of the conference. The Volunteer role this year
will mainly involve working with the organizers to prepare for the
conference by providing technical assistance to attendees, managing
online Q and poster sessions, and supporting active communication in
our online environment.

## Compensation

* A Complimentary Conference Registration, offering access to all open
sessions (i.e., parallel paper presentations, demonstrations, and
workshops) and conference proceedings.
* Free lunches and refreshments during breaks.
* Volunteer garments.
* Free admission to all social events.

Please note that volunteers are responsible for their own travel and
accommodation arrangements.

If you need additional travel funding, please consider SIGPLAN PAC
Funding 
(https://urldefense.com/v3/__http://www.sigplan.org/PAC/__;!!IBzWLUs!WcCkdepPhhXD11Cs7DxUFXnP1L29tct4cGmbIRLfHGmcJlvQBBkW6XJ-Z2FlUhX-fCizmrbdhLiJJEnryvhYs477rIqxE7FNawJcUAfZ9zE$
 ) and PLMW
(https://urldefense.com/v3/__https://icfp23.sigplan.org/track/plmw-icfp-2023__;!!IBzWLUs!WcCkdepPhhXD11Cs7DxUFXnP1L29tct4cGmbIRLfHGmcJlvQBBkW6XJ-Z2FlUhX-fCizmrbdhLiJJEnryvhYs477rIqxE7FNawJcowPYV74$
 ).

[TYPES/announce] ICFP 2023: Call for Tutorial, Panel, and Discussion Proposals

[ICFP Publicity]

[ The Types Forum (announcements only),
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

ICFP 2023
CALL FOR TUTORIAL, PANEL, AND DISCUSSION PROPOSALS
28th ACM SIGPLAN International Conference on Functional Programming


September 4 - 9, 2023
Seattle, WA, USA
https://urldefense.com/v3/__https://icfp23.sigplan.org/__;!!IBzWLUs!Xn8FNGF0gG7I2WNfEx7UhCWwIwbquhO6VXefumtkcbCz-8I0Zj33YHjeXPEv4rTWchKr-2eLEY8YHA9u_hbOQR73UDyIpDc_gn-GjO-Dtuw$
 


The 28th ACM SIGPLAN International Conference on Functional
Programming will be held in Seattle, WA, USA on September 4 - 9,
2023, with the option of virtual participation. ICFP provides a forum
for researchers and developers to hear about the latest work on the
design, implementations, principles, and uses of functional
programming.

Proposals are invited for tutorials, lasting approximately 3 hours each,
to be presented during ICFP and its co-located workshops and other events.
The tutorials may target an audience who is interested in commercial uses
of functional programming, but we also welcome tutorials whose primary
audience is researchers rather than practitioners. Tutorials may focus either
on a concrete technology or on a theoretical or mathematical tool. Ideally,
tutorials will have a concrete result, such as "Learn to do X with Y"
rather than "Learn language Y".

Just like last year, following the success of the #ShutDownPL event, we are also
inviting proposals for panels and discussions on topics of broader interest
to the PL community.

Tutorials, panels, and discussions may occur before or after ICFP,
co-located with the associated workshops, on September 4 or September 8-9.


--

Submission details

Deadline for submission: May 23rd, 2023
Notification of acceptance: May 26th, 2023

Prospective organizers of tutorials are invited to submit a completed
tutorial proposal form in plain text format to the ICFP 2023 workshop
co-chairs (Arthur Azevedo de Amorim and Yannick Forster), via email to

icfp-workshops-2023 AT googlegroups.com

by May 23rd, 2023. Please note that this is a firm deadline.

The proposal form is available at:

https://urldefense.com/v3/__http://www.icfpconference.org/icfp2023-files/icfp23-panel-form.txt__;!!IBzWLUs!Xn8FNGF0gG7I2WNfEx7UhCWwIwbquhO6VXefumtkcbCz-8I0Zj33YHjeXPEv4rTWchKr-2eLEY8YHA9u_hbOQR73UDyIpDc_gn-G-2IPkQU$
 
https://urldefense.com/v3/__http://www.icfpconference.org/icfp2023-files/icfp23-tutorials-form.txt__;!!IBzWLUs!Xn8FNGF0gG7I2WNfEx7UhCWwIwbquhO6VXefumtkcbCz-8I0Zj33YHjeXPEv4rTWchKr-2eLEY8YHA9u_hbOQR73UDyIpDc_gn-GrRvuVdY$
 

--

Selection committee

The proposals will be evaluated by a committee comprising the
following members of the ICFP 2023 organizing committee, together
with the members of the SIGPLAN executive committee.

Workshop Co-Chair: Arthur Azevedo de Amorim (Boston University)
Workshop Co-Chair: Yannick Forster (Inria Nantes)
General Chair: Nikhil Swamy (Microsoft Research)
Program Chair: Sam Lindley (University of Edinburgh)

--

Further information

Any queries should be addressed to the workshop co-chairs (Arthur
Azevedo de Amorim and Yannick Forster), via email to
icfp-workshops-2023 AT googlegroups.com

[TYPES/announce] ICFP 2023: Last Call for Papers

[ICFP Publicity]

[ The Types Forum (announcements only),
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

 PACMPL Volume 7, Issue ICFP 2023
   Call for Papers

   Accepted papers to be invited for presentation at
The 28th ACM SIGPLAN International Conference on Functional Programming
Seattle, USA
 
https://urldefense.com/v3/__http://icfp23.sigplan.org/__;!!IBzWLUs!R72XkDRwVC0sTeip1mYCP8y0XwPkmf6uu1eL2ePKvoPuuyF0N9cZRfQ2Ce_403ESn0M3vQ4TqMUUaC5L1QJrQ0uYHzkUXRlLfj7z4y8brr4$
 

### Important dates

(All dates are in 2023 at 11.59pm anywhere on earth.)

Submission deadline:   1 March 2023 (Wednesday)
   
(https://urldefense.com/v3/__https://icfp23.hotcrp.com__;!!IBzWLUs!R72XkDRwVC0sTeip1mYCP8y0XwPkmf6uu1eL2ePKvoPuuyF0N9cZRfQ2Ce_403ESn0M3vQ4TqMUUaC5L1QJrQ0uYHzkUXRlLfj7zlip7GKA$
 )
Author response:   1 May (Monday)--4 May (Thursday)
Round 1 notification:  18 May (Thursday)
Round 2 notification:  29 June (Thursday)
Camera-ready deadline: 20 July (Thursday)
Conference:4 September (Monday)--9 September (Saturday)

### About PACMPL

Proceedings of the ACM on Programming Languages (PACMPL
) is a Gold Open Access journal publishing
research on all aspects of programming languages, from design to
implementation and from mathematical formalisms to empirical
studies. Each issue of the journal is devoted to a particular subject
area within programming languages and will be announced through
publicised Calls for Papers, like this one.

### Scope

[PACMPL](https://urldefense.com/v3/__https://pacmpl.acm.org/__;!!IBzWLUs!R72XkDRwVC0sTeip1mYCP8y0XwPkmf6uu1eL2ePKvoPuuyF0N9cZRfQ2Ce_403ESn0M3vQ4TqMUUaC5L1QJrQ0uYHzkUXRlLfj7z_kA1tRI$
 ) issue ICFP 2023 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. Topics of
interest include (but are not limited to):

  * Language Design: concurrency, parallelism, and distribution;
modularity; components and composition; metaprogramming; macros;
pattern matching; type systems; type inference; dependent types;
effect types; gradual types; refinement types; session types;
interoperability; domain-specific languages; imperative
programming; object-oriented programming; logic programming;
probabilistic programming; reactive programming; generic
programming; bidirectional programming.

  * Implementation: abstract machines; virtual machines;
interpretation; compilation; compile-time and run-time
optimisation; garbage collection and memory management; runtime
systems; 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; build systems;
program synthesis.

  * Foundations: formal semantics; lambda calculus; program
equivalence; rewriting; type theory; logic; category theory;
computational effects; continuations; control; state; names and
binding; program verification.

  * Analysis and Transformation: control flow; data flow; abstract
interpretation; partial evaluation; program calculation.

  * Applications: symbolic computing; formal-methods tools; artificial
intelligence; systems programming; distributed systems and web
programming; hardware design; databases; scientific and numerical
computing; graphical user interfaces; graphics and multimedia; GPU
programming; scripting; system administration; security.

  * Education: teaching introductory programming; mathematical proof;
algebra.

Submissions will be evaluated according to their relevance,
correctness, significance, originality, and clarity. Each submission
should explain its contributions in both general and technical terms,
clearly identifying what has been accomplished, explaining why it is
significant, and comparing it with previous work. The technical
content should be accessible to a broad audience.

PACMPL issue ICFP 2023 also welcomes submissions in two separate
categories — Functional Pearls and Experience Reports — that must be
marked as such when submitted and that need not report original
research results. Detailed guidelines on both categories are given at
the end of this call.

Submissions from underrepresented groups are 

[TYPES/announce] ICFP 2023 Call for Papers

[ICFP Publicity]

[ The Types Forum (announcements only),
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

   PACMPL Volume 7, Issue ICFP 2023
   Call for Papers

   Accepted papers to be invited for presentation at
The 28th ACM SIGPLAN International Conference on Functional Programming
Seattle, USA
 
https://urldefense.com/v3/__http://icfp23.sigplan.org/__;!!IBzWLUs!TcGd5Wy6jluREp3aRh0aSlHbTTuFhapLvh2xUR7yHaqrnvFYQyXZRVaSAkkg-50H6XU3viwlQdWAYb2vROGamtrTqqQPkNGzHqa-SDQqxpk$
 

### Important dates

(All dates are in 2023 at 11.59pm anywhere on earth.)

Submission deadline:   1 March 2023 (Wednesday)
   
(https://urldefense.com/v3/__https://icfp23.hotcrp.com__;!!IBzWLUs!TcGd5Wy6jluREp3aRh0aSlHbTTuFhapLvh2xUR7yHaqrnvFYQyXZRVaSAkkg-50H6XU3viwlQdWAYb2vROGamtrTqqQPkNGzHqa-EN9efRQ$
 )
Author response:   1 May (Monday)--4 May (Thursday)
Round 1 notification:  18 May (Thursday)
Round 2 notification:  29 June (Thursday)
Camera-ready deadline: 20 July (Thursday)
Conference:4 September (Monday)--9 September (Saturday)

### About PACMPL

Proceedings of the ACM on Programming Languages (PACMPL
) is a Gold Open Access journal publishing
research on all aspects of programming languages, from design to
implementation and from mathematical formalisms to empirical
studies. Each issue of the journal is devoted to a particular subject
area within programming languages and will be announced through
publicised Calls for Papers, like this one.

### Scope

[PACMPL](https://urldefense.com/v3/__https://pacmpl.acm.org/__;!!IBzWLUs!TcGd5Wy6jluREp3aRh0aSlHbTTuFhapLvh2xUR7yHaqrnvFYQyXZRVaSAkkg-50H6XU3viwlQdWAYb2vROGamtrTqqQPkNGzHqa-XxYrLSk$
 ) issue ICFP 2023 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. Topics of
interest include (but are not limited to):

  * Language Design: concurrency, parallelism, and distribution;
modularity; components and composition; metaprogramming; macros;
pattern matching; type systems; type inference; dependent types;
effect types; gradual types; refinement types; session types;
interoperability; domain-specific languages; imperative
programming; object-oriented programming; logic programming;
probabilistic programming; reactive programming; generic
programming; bidirectional programming.

  * Implementation: abstract machines; virtual machines;
interpretation; compilation; compile-time and run-time
optimisation; garbage collection and memory management; runtime
systems; 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; build systems;
program synthesis.

  * Foundations: formal semantics; lambda calculus; program
equivalence; rewriting; type theory; logic; category theory;
computational effects; continuations; control; state; names and
binding; program verification.

  * Analysis and Transformation: control flow; data flow; abstract
interpretation; partial evaluation; program calculation.

  * Applications: symbolic computing; formal-methods tools; artificial
intelligence; systems programming; distributed systems and web
programming; hardware design; databases; scientific and numerical
computing; graphical user interfaces; graphics and multimedia; GPU
programming; scripting; system administration; security.

  * Education: teaching introductory programming; mathematical proof;
algebra.

Submissions will be evaluated according to their relevance,
correctness, significance, originality, and clarity. Each submission
should explain its contributions in both general and technical terms,
clearly identifying what has been accomplished, explaining why it is
significant, and comparing it with previous work. The technical
content should be accessible to a broad audience.

PACMPL issue ICFP 2023 also welcomes submissions in two separate
categories — Functional Pearls and Experience Reports — that must be
marked as such when submitted and that need not report original
research results. Detailed guidelines on both categories are given at
the end of this call.

Submissions from underrepresented groups are 

[TYPES/announce] ICFP 2023: Call for Workshop and Co-Located Event

[ICFP Publicity]

[ The Types Forum (announcements only),
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

CALL FOR WORKSHOP AND CO-LOCATED EVENT PROPOSALS
ICFP 2023
 28th ACM SIGPLAN International Conference on Functional Programming


  September 4 - 9, 2023
Seattle, WA, USA

https://urldefense.com/v3/__https://icfp23.sigplan.org/__;!!IBzWLUs!TJNnIz3lUZx7T9plQpVFi9BkG5CWF-jEAPpzp7Tjp1wayAVMYlJPncQXDbNp8v0bwCNNzZm6yBb97_CsoSaU9-xDHptT6An7sIuk7BXrBP8$
 

The 28th ACM SIGPLAN International Conference on Functional
Programming will be held in Seattle, WA, USA on September 4 - 9,
2023, with the option of virtual participation. ICFP provides a forum
for researchers and developers to hear about the latest work on the
design, implementations, principles, and uses of functional
programming.

Proposals are invited for workshops (and other co-located events,
such as symposiums) to be affiliated with ICFP 2023 and sponsored by
SIGPLAN. These events should be less formal and more focused than
ICFP itself, include sessions that enable interaction among the
attendees, and foster the exchange of new ideas. The preference is
for one-day events, but other schedules can also be considered.

The workshops are scheduled to occur on September 4th (the day before
ICFP) and September 8-9th (the two days after ICFP).

--

Submission details
 Deadline for submission: December 22, 2022
 Notification of acceptance:  January  13, 2023

Prospective organizers of workshops or other co-located events are
invited to submit a completed workshop proposal form in plain text
format to the ICFP 2023 workshop co-chairs (Arthur Azevedo de Amorim
and Yannick Forster) via email to

   icfp-workshops-2...@googlegroups.com

by December 22, 2022. (For proposals of co-located events other than
workshops, please fill in the workshop proposal form and just leave
blank any sections that do not apply.) Please note that this is a
firm deadline.

Organizers will be notified whether their event proposal is accepted
by January 13, 2023, and if successful, depending on the event, they
will be asked to produce a final report after the event has taken
place that is suitable for publication in SIGPLAN Notices.

The proposal form is available at:

https://urldefense.com/v3/__http://www.icfpconference.org/icfp2023-files/icfp23-workshops-form.txt__;!!IBzWLUs!TJNnIz3lUZx7T9plQpVFi9BkG5CWF-jEAPpzp7Tjp1wayAVMYlJPncQXDbNp8v0bwCNNzZm6yBb97_CsoSaU9-xDHptT6An7sIuk0DhCQio$
 

Further information about SIGPLAN sponsorship is available at:

https://urldefense.com/v3/__http://www.sigplan.org/Resources/Proposals/Sponsored/__;!!IBzWLUs!TJNnIz3lUZx7T9plQpVFi9BkG5CWF-jEAPpzp7Tjp1wayAVMYlJPncQXDbNp8v0bwCNNzZm6yBb97_CsoSaU9-xDHptT6An7sIuktf5YbqI$
 

--

Selection committee

The proposals will be evaluated by a committee comprising the
following members of the ICFP 2023 organizing committee, together
with the members of the SIGPLAN executive committee.

 Workshop Co-Chair: Arthur Azevedo de Amorim   (Boston University)
 Workshop Co-Chair: Yannick Forster (Inria Nantes)
 General Chair: Nikhil Swamy  (Microsoft Research)
 Program Chair: Sam Lindley  (University of Edinburgh)


--

Further information

Any queries should be addressed to the workshop co-chairs (Arthur
Azevedo de Amorim and Yannick Forster), via email to
icfp-workshops-2...@googlegroups.com.

[TYPES/announce] ICFP 2022: Call for Tutorials, Panels, and Discussions

[ICFP Publicity]

[ The Types Forum (announcements only),
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

CALL FOR TUTORIAL, PANEL, AND DISCUSSION PROPOSALS

ICFP 2022

 27th ACM SIGPLAN International Conference on Functional Programming



Sun 11 - Fri 16 September 2022

 Ljubljana, Slovenia

 
https://urldefense.com/v3/__https://icfp22.sigplan.org/__;!!IBzWLUs!RIYjYhX-p3kAjoee8mk3ljkI3mZoKw9qgDhnyPP9inZ5dtxLYniHmG_q9ZqLdqCuVfXOxxA4B22S8UZduvxOdbyuz53z3bPaHradr7oQmI4$
 



The 27th ACM SIGPLAN International Conference on Functional Programming
will be held on September 11-16, 2022 in Ljubljana, Slovenia.
ICFP provides a forum for researchers and developers to hear about the
latest work on the design, implementations, principles, and uses of
functional programming.


Proposals are invited for tutorials, lasting approximately 3 hours each,
to be presented during ICFP and its co-located workshops and other events.
The tutorials may target an audience who is interested in commercial uses
of functional programming, but we also welcome tutorials whose primary
audience is researchers rather than practitioners. Tutorials may focus either
on a concrete technology or on a theoretical or mathematical tool. Ideally,
tutorials will have a concrete result, such as "Learn to do X with Y"
rather than "Learn language Y".


Just like last year, following the success of the #ShutDownPL event, we are also
inviting proposals for panels and discussions on topics of broader interest
to the PL community.


Tutorials, panels, and discussions may occur before or after ICFP,
co-located with the associated workshops, on September 11 or September 15-16.


--


Submission details

 Deadline for submission: June 24st, 2022

 Notification of acceptance:  July  15th, 2022



Prospective organizers of tutorials are invited to submit a completed
tutorial proposal form in plain text format to the ICFP 2022 workshop
co-chairs (Arthur Azevedo de Amorim and Zoe Paraskevopoulou), via email to


 icfp-workshops-2...@googlegroups.com


by June 24st, 2022. Please note that this is a firm deadline.


Organizers will be notified if their event proposal is accepted by
July  8th, 2022.


The proposal form is available at:


https://urldefense.com/v3/__http://www.icfpconference.org/icfp2022-files/icfp22-panel-form.txt__;!!IBzWLUs!RIYjYhX-p3kAjoee8mk3ljkI3mZoKw9qgDhnyPP9inZ5dtxLYniHmG_q9ZqLdqCuVfXOxxA4B22S8UZduvxOdbyuz53z3bPaHradr4myp2I$
 
https://urldefense.com/v3/__http://www.icfpconference.org/icfp2022-files/icfp22-tutorials-form.txt__;!!IBzWLUs!RIYjYhX-p3kAjoee8mk3ljkI3mZoKw9qgDhnyPP9inZ5dtxLYniHmG_q9ZqLdqCuVfXOxxA4B22S8UZduvxOdbyuz53z3bPaHradbG2aE2I$
 


--


Selection committee


The proposals will be evaluated by a committee comprising the
following members of the ICFP 2022 organizing committee.



 Tutorials Co-Chair: Arthur Azevedo de Amorim   (Boston University)

 Tutorials Co-Chair: Zoe Paraskevopoulou  (Northeastern University)

 General Chair:  Andrej Bauer (University of Ljubljana)

 Program Chair:  Zena M. Ariola  (University of Oregon)


--



Further information



Any queries should be addressed to the tutorial co-chairs
(Arthur Azevedo de Amorim and Zoe Paraskevopoulou),
via email to icfp-workshops-2...@googlegroups.com.

[TYPES/announce] Call for Papers: PACMPL issue ICFP 2022

[ICFP Publicity]

[ The Types Forum (announcements only),
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

   PACMPL Volume 6, Issue ICFP 2022

Call for Papers

   Accepted papers to be invited for presentation at
The 27th ACM SIGPLAN International Conference on Functional Programming

   Ljubljana, Slovenia


https://urldefense.com/v3/__http://icfp22.sigplan.org/__;!!IBzWLUs!Hno6BNTeOYXI2TtHLT0KmewBlK4HTBq3NH4nWmbAfQmE3WKsCkeexkP63DrA5ILTRf9SzNfv6Qch5A$
 

### Important dates

Submissions due:  2 March 2022 (Wednesday), Anywhere on Earth
Author response:  2 May (Monday) - 5 May (Thursday)
Notification: 21 May (Thursday)
Submission of revised papers: 16 June (Thursday)
Final copy due:   21 July (Thursday)
Conference:   11 September (Sunday) - 16 September (Friday)


[PACMPL](https://urldefense.com/v3/__https://pacmpl.acm.org/__;!!IBzWLUs!Hno6BNTeOYXI2TtHLT0KmewBlK4HTBq3NH4nWmbAfQmE3WKsCkeexkP63DrA5ILTRf9SzNcP7eE18w$
 ) issue ICFP 2022 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. Topics of
interest include (but are not limited to):

* Language Design: concurrency, parallelism, and distribution;
   modules; components and composition; metaprogramming; macros;
   pattern matching; type systems; type inference; dependent types;
   session types; gradual typing; refinement types; interoperability;
   domain-specific languages; imperative programming; object-oriented
   programming; logic programming; probabilistic programming;
   reactive programming; generic programming; bidirectional
   programming.

* Implementation: abstract machines; virtual machines;
   interpretation; compilation; compile-time and run-time
   optimization; garbage collection and memory management; runtime
   systems; 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; build systems;
   program synthesis.

* Foundations: formal semantics; lambda calculus; program
   equivalence; rewriting; type theory; logic; category theory;
   monads; continuations; control; state; effects; names and binding;
   program verification.

* Analysis and Transformation: control flow; data flow; abstract
   interpretation; partial evaluation; program calculation.

* Applications: 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;
   graphics and multimedia; GPU programming; scripting; system
   administration; security.

* Education: teaching introductory programming; parallel
   programming; mathematical proof; algebra.

Submissions will be evaluated according to their relevance,
correctness, significance, originality, and clarity. Each submission
should explain its contributions in both general and technical terms,
clearly identifying what has been accomplished, explaining why it is
significant, and comparing it with previous work. The technical
content should be accessible to a broad audience.
PACMPL issue ICFP 2022 also welcomes submissions in two separate
categories — Functional Pearls and Experience Reports — that must be
marked as such when submitted and that need not report original
research results. Detailed guidelines on both categories are given at
the end of this call.
Please contact the associate editor if you have questions or are
concerned about the appropriateness of a topic.

### About PACMPL

Proceedings of the ACM on Programming Languages (PACMPL
) is a Gold Open Access journal publishing
research on all aspects of programming languages, from design to
implementation and from mathematical formalisms to empirical
studies. Each issue of the journal is devoted to a particular subject
area within programming languages and will be announced through
publicized Calls for Papers, like this one.

### Preparation of submissions

**Deadline**: The deadline for submissions is **Wednesday, March 2, 2022**,
Anywhere on Earth 

[TYPES/announce] ICFP 2019: Call For Workshop Proposals

[ICFP Publicity]

[ The Types Forum (announcements only),
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

CALL FOR WORKSHOP AND CO-LOCATED EVENT PROPOSALS
ICFP 2019
 24th ACM SIGPLAN International Conference on Functional Programming


   August 18 - 23, 2019
  Berlin, Germany
https://icfp19.sigplan.org/

The 24th ACM SIGPLAN International Conference on Functional Programming
will be held in Berlin, Germany on August 18-23, 2019.
ICFP provides a forum for researchers and developers to hear about the
latest work on the design, implementations, principles, and uses of
functional programming.

Proposals are invited for workshops (and other co-located events, such
as symposiums) to be affiliated with ICFP 2019 and sponsored by
SIGPLAN. These events should be less formal and more focused than ICFP
itself, include sessions that enable interaction among the attendees,
and foster the exchange of new ideas. The preference is for one-day
events, but other schedules can also be considered.

The workshops are scheduled to occur on August 18th (the day
before ICFP) and 22-23th of August (the two days after ICFP).

--

Submission details
 Deadline for submission: November 25, 2018
 Notification of acceptance:  December 23, 2018

Prospective organizers of workshops or other co-located events are
invited to submit a completed workshop proposal form in plain text
format to the ICFP 2019 workshop co-chairs
(Jennifer Hackett and Christophe Scholliers), via email to

icfp-workshops-2...@googlegroups.com

by November 25, 2018. (For proposals of co-located events other than
workshops, please fill in the workshop proposal form and just leave
blank any sections that do not apply.) Please note that this is a firm
deadline.

Organizers will be notified if their event proposal is accepted by
December 23, 2018, and if successful, depending on the event, they
will be asked to produce a final report after the event has taken
place that is suitable for publication in SIGPLAN Notices.

The proposal form is available at:

http://www.icfpconference.org/icfp2019-files/icfp19-workshops-form.txt

Further information about SIGPLAN sponsorship is available at:

http://www.sigplan.org/Resources/Proposals/Sponsored/

--

Selection committee

The proposals will be evaluated by a committee comprising the
following members of the ICFP 2019 organizing committee, together with
the members of the SIGPLAN executive committee.

 Workshop Co-Chair: Jennifer Hackett(University of Nottingham)
 Workshop Co-Chair: Christophe Scholliers(University of Ghent)
 General Chair: Derek Dreyer (MPI-SWS)
 Program Chair: François Potier(Inria)


--

Further information

Any queries should be addressed to the workshop co-chairs (Jennifer
Hackett and Christophe Scholliers), via email to
icfp-workshops-2...@googlegroups.com

[TYPES/announce] ICFP09 Final Call for Participation

[Matthew Fluet (ICFP Publicity Chair)]

[ The Types Forum (announcements only), 
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

=
 Final Call for Participation

The 14th ACM SIGPLAN International Conference
on Functional Programming (ICFP 2009)

  http://www.cs.nott.ac.uk/~gmh/icfp09.html

  Edinburgh, Scotland, 31 August - 2 September 2009
=

   * Accommodation Deadline: July 20, 2009 *
   Due to the overlap with Edinburgh Festival, accommodations may be
difficult to secure after the deadline.  Reserve now!
   http://www.haskell.org/haskellwiki/ICFP_2009_Local_Arrangements

* Early Registration Deadline: July 30, 2009 *
 http://www.regmaster.com/conf/icfp2009.html


ICFP 2009 provides a forum for researchers and developers to hear
about the latest work on the design, implementations, principles, and
uses of functional programming. The conference covers the entire
spectrum of work, from practice to theory, including its peripheries.

Preliminary program:
 * Abstracts:
  + http://web.cecs.pdx.edu/~apt/icfp09_accepted_papers/accepted.html
 * Schedule:
  + http://web.cecs.pdx.edu/~apt/icfp09_preliminary_program.pdf
 * Invited speakers:
   + Guy Steele -- Organizing Functional Code for Parallel Execution:
 or, foldl and foldr Considered Slightly Harmful
   + Benjamin Pierce -- Lambda, the Ultimate TA: Using a Proof
 Assistant to Teach Programming Language Foundations
   + Dan Piponi -- Commutative Monads, Diagrams and Knots


Schedule including related workshops:
 * Aug 30: ACM SIGPLAN Workshop on ML
 * Aug 30: ACM SIGPLAN Workshop on Generic Programming
 * Aug 31-Sep 2: ICFP09
 * Sep  3: ACM SIGPLAN Haskell Symposium
 * Sep  3: ACM SIGPLAN Developer Tracks on Functional Programming
 * Sep  4: Commercial Users of Functional Programming
 * Sep  4: ACM SIGPLAN Workshop on Mechanizing Metatheory
 * Sep  4: ACM SIGPLAN Workshop on Approaches and Applications of
   Inductive Programming
 * Sep  5: ACM SIGPLAN Erlang Workshop
 * Sep  5: ACM SIGPLAN Developer Tracks on Functional Programming
 * Sep  5: ACM SIGPLAN Haskell Implementors Workshop


Conference organizers:
 * General Chair: Graham Hutton (University of Nottingham)
 * Program Chair: Andrew Tolmach (Portland State University)
 * Local Arrangements Chairs: Philip Wadler (University of Edinburgh),
   Kevin Hammond (University of St Andrews), and
   Gregory Michaelson (Heriot-Watt University)
 * Workshop Co-Chairs: Christopher Stone (Harvey Mudd College), and
   Michael Sperber (DeinProgramm)
 * Programming Contest Chair: Andrew Gill (University of Kansas)
 * Publicity Chair: Matthew Fluet (Toyota Technological Institute at Chicago)

[TYPES/announce] ICFP09 Call for Participation

[Matthew Fluet (ICFP Publicity Chair)]

[ The Types Forum (announcements only), 
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

=
Call for Participation

The 14th ACM SIGPLAN International Conference
on Functional Programming (ICFP 2009)

  http://www.cs.nott.ac.uk/~gmh/icfp09.html

  Edinburgh, Scotland, 31 August - 2 September 2009
=

ICFP 2009 provides a forum for researchers and developers to hear
about the latest work on the design, implementations, principles, and
uses of functional programming. The conference covers the entire
spectrum of work, from practice to theory, including its peripheries.

Preliminary program:
 * Accepted papers:
  + http://web.cecs.pdx.edu/~apt/icfp09_accepted_papers/accepted.html
 * Invited speakers:
   + Guy Steele -- Organizing Functional Code for Parallel Execution:
 or, foldl and foldr Considered Slightly Harmful
   + Benjamin Pierce -- Lambda, the Ultimate TA: Using a Proof
 Assistant to Teach Programming Language Foundations
   +Dan Piponi -- Commutative Monads, Diagrams and Knots


Schedule including related workshops:
 * Aug 30: ACM SIGPLAN Workshop on ML
 * Aug 30: ACM SIGPLAN Workshop on Generic Programming
 * Aug 31-Sep 2: ICFP09
 * Sep  3: ACM SIGPLAN Haskell Symposium
 * Sep  3: ACM SIGPLAN Developer Tracks on Functional Programming
 * Sep  4: Commercial Users of Functional Programming
 * Sep  4: ACM SIGPLAN Workshop on Mechanizing Metatheory
 * Sep  4: ACM SIGPLAN Workshop on Approaches and Applications of
   Inductive Programming
 * Sep  5: ACM SIGPLAN Erlang Workshop
 * Sep  5: ACM SIGPLAN Developer Tracks on Functional Programming
 * Sep  5: ACM SIGPLAN Haskell Implementors Workshop


Registration information:
 * http://www.regmaster.com/conf/icfp2009.html
 * Early registration deadline: July 30, 2009


Local arrangements (including travel and accommodation):
 * http://www.haskell.org/haskellwiki/ICFP_2009_Local_Arrangements
 * Conference reservation/rate deadline: July 20, 2009
 * ICFP09 coincides with the final week of the Edinburgh International
   Festival, one of the premier arts and cultural festivals in the
   world.  The opportunity to attend the Festival is a plus!  Due to
   the popularity of Edinburgh during the festival period, we
   strongly recommend booking accommodation early.


Conference organizers:
 * General Chair: Graham Hutton (University of Nottingham)
 * Program Chair: Andrew Tolmach (Portland State University)
 * Local Arrangements Chairs: Philip Wadler (University of Edinburgh),
   Kevin Hammond (University of St Andrews), and
   Gregory Michaelson (Heriot-Watt University)
 * Workshop Co-Chairs: Christopher Stone (Harvey Mudd College), and
   Michael Sperber (DeinProgramm)
 * Programming Contest Chair: Andrew Gill (University of Kansas)
 * Publicity Chair: Matthew Fluet (Toyota Technological Institute at Chicago)


=
=

And, don't forget about the ICFP Programming Contest this weekend!!

 * http://www.icfpcontest.org
 * Friday, June 26 to Monday, June 29
 * Organizers: Computer Systems Design Laboratory (University of Kansas)

[TYPES/announce] ICFP09 Accepted Papers

[Matthew Fluet (ICFP Publicity Chair)]

[ The Types Forum (announcements only), 
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

   Accepted Papers
ICFP 2009: International Conference on Functional Programming
  Edinburgh, Scotland, 31 August - 2 September 2009
  http://www.cs.nott.ac.uk/~gmh/icfp09.html

The ICFP 2009 Program Chair and Committee are pleased to announce that
the following papers have been accepted for the conference.

Additional information regarding the final program, invited speakers,
and registration will be forthcoming.  However, the Local Arrangements
Co-Chairs would like to remind participants of the following:

 * ICFP'09 coincides with the final week of the Edinburgh
   International Festival, one of the premier arts and cultural
   festivals in the world.  The opportunity to attend the Festival is
   a plus!  Due to the popularity of Edinburgh during the festival
   period, we recommend booking accommodation early.

More details regarding accommodation may be obtained from
the ICFP 2009 Local Arrangements webpage:
 http://www.haskell.org/haskellwiki/ICFP_2009_Local_Arrangements


   Accepted papers
   ~~~

A CONCURRENT ML LIBRARY IN CONCURRENT HASKELL
   Avik Chaudhuri

A THEORY OF TYPED COERCIONS AND ITS APPLICATIONS
   Nikhil Swamy, Michael Hicks and Gavin Bierman

A UNIVERSE OF BINDING AND COMPUTATION
   Daniel Licata and Robert Harper

ATTRIBUTE GRAMMARS FLY FIRST-CLASS: HOW TO DO ASPECT ORIENTED
PROGRAMMING IN HASKELL
   Marcos Viera, S. Doaitse Swierstra and Wouter S. Swierstra

AUTOMATICALLY RESTFUL WEB APPLICATIONS OR, MARKING MODULAR
SERIALIZABLE CONTINUATIONS
   Jay McCarthy

BEAUTIFUL DIFFERENTIATION
   Conal Elliott

BIORTHOGONALITY, STEP-INDEXING AND COMPILER CORRECTNESS
   Nick Benton and Chung-Kil Hur

CAUSAL COMMUTATIVE ARROWS AND THEIR OPTIMIZATION
   Hai Liu, Eric Cheng and Paul Hudak

COMPLETE AND DECIDABLE TYPE INFERENCE FOR GADTS
   Tom Schrijvers, Simon Peyton Jones, Martin Sulzmann and
   Dimitrios Vytiniotis

CONTROL-FLOW ANALYSIS OF FUNCTION CALLS AND RETURNS BY ABSTRACT
INTERPRETATION
   Jan Midtgaard and Thomas P. Jensen

EDUCATIONAL PEARL: FUN FOR FRESHMEN KIDS
   Matthias Felleisen, Robert Bruce Findler, Matthew Flatt and
   Shriram Krishnamurthi

EFFECTIVE INTERACTIVE PROOFS FOR HIGHER-ORDER IMPERATIVE PROGRAMS
   Adam Chlipala, Gregory Malecha, Greg Morrisett, Avraham Shinnar and
   Ryan Wisnesky

EXPERIENCE REPORT: EMBEDDED, PARALLEL COMPUTER-VISION WITH A
FUNCTIONAL DSL
   Ryan Newton and Teresa Ko

EXPERIENCE REPORT: HASKELL IN THE REALWORLD
   Curt Sampson

EXPERIENCE REPORT: OCAML FOR AN INDUSTRIAL-STRENGTH STATIC ANALYSIS
FRAMEWORK
   Pascal Cuoq and Julien Signoles

EXPERIENCE REPORT: OCSIGEN, A WEB PROGRAMMING FRAMEWORK
   Vincent Balat, Jérôme Vouillon and Boris Yakobowski

EXPERIENCE REPORT: SEL4 -- FORMALLY VERIFYING A HIGH-PERFORMANCE
MICROKERNEL
   Gerwin Klein, Philip Derrin and Kevin Elphinstone

FINDING RACE CONDITIONS IN ERLANG WITH QUICKCHECK AND PULSE
   Koen Claessen, Michal Palka, Nicholas Smallbone, John Hughes,
   Hans Svensson, Thomas Arts and Ulf Wiger

FREE THEOREMS INVOLVING TYPE CONSTRUCTOR CLASSES
   Janis Voigtlaender

GENERIC PROGRAMMING WITH FIXED POINTS FOR MUTUALLY RECURSIVE DATATYPES
   Alexey Rodriguez, Stefan Holdermans, Andres Löh and Johan Jeuring

IDENTIFYING QUERY INCOMPATIBILITIES WITH EVOLVING XML SCHEMAS
   Pierre Geneves, Nabil Layaida and Vincent Quint

IMPLEMENTING FIRST-CLASS POLYMORPHIC DELIMITED CONTINUATIONS BY A
TYPE-DIRECTED SELECTIVE CPS-TRANSFORM
   Tiark Rompf, Ingo Maier and Martin Odersky

LA TOUR D'HANOï
   Ralf Hinze

NON-PARAMETRIC PARAMETRICITY
   Georg Neis, Derek Dreyer and Andreas Rossberg

OXENSTORED: AN EFFICIENT HIERARCHICAL AND TRANSACTIONAL DATABASE USING
FUNCTIONAL PROGRAMMING WITH REFERENCE CELL COMPARISONS
   Thomas Gazagnaire and Vincent Hanquez

PARALLEL CONCURRENT ML
   John Reppy, Claudio Russo and Yingqi Xiao

PARTIAL MEMOIZATION OF CONCURRENCY AND COMMUNICATION
   Suresh Jagannathan, KC Sivaramakrishnan and Lukasz Ziarek

PURELY FUNCTIONAL LAZY NON-DETERMINISTIC PROGRAMMING
   Sebastian Fischer, Oleg Kiselyov and Chung-chieh Shan

RUNTIME SUPPORT FOR MULTICORE HASKELL
   Simon Marlow, Simon Peyton Jones and Satnam Singh

SAFE FUNCTIONAL REACTIVE PROGRAMMING THROUGH DEPENDENT TYPES
   Neil Sculthorpe and Henrik Nilsson

SCRIBBLE: CLOSING THE BOOK ON AD HOC DOCUMENTATION TOOLS
   Matthew Flatt, Eli Barzilay and Robert Bruce Findler

USING OBJECTIVE CAML TO DEVELOP SAFETY-CRITICAL EMBEDDED TOOL IN A
CERTIFICATION FRAMEWORK
   Bruno Pagano, Olivier Andrieu, Thomas Moniot, Benjamin Canou,
   Emmanuel Chailloux, Philippe Wang, Pascal Manoury and
   Jean-Louis Colaco

[TYPES/announce] International Summer School on Advances in Programming Languages (precedes ICFP'09)

[Matthew Fluet (ICFP Publicity Chair)]

[ The Types Forum (announcements only), 
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

   International Summer School on Advances in Programming Languages
25th-28th August, 2009
 Heriot-Watt University, Edinburgh, Scotland
   http://www.macs.hw.ac.uk/~greg/ISS-AiPL


Overview


This four-day residential International Summer School on Advances in
Programming Languages has a major theme of Concurrency, Distribution,
and Multicore. Intended primarily for postgraduate research students,
the School offers lectures and practical sessions on an engaging blend
of cutting edge theoretical and practical techniques from
international experts.

The Summer School is supported by the Scottish Informatics and
Computer Science Alliance (http://www.sicsa.ac.uk/), a Scottish
Funding Council Research Pool. Participants from SICSA member
institutions may attend at no cost.

Confirmed Topics/Speakers

* Static and dynamic languages,
  Prof Philip Wadler, University of Edinburgh
* Compiler technology for data-parallel languages,
  Dr Sven-Bodo Scholz, University of Hertfordshire
* New applications of parametricity,
  Dr Janis Voigtlander, Technical University of Dresden
* Automatic vectorising compilation,
  Dr Paul Cockshott, University of Glasgow
* Foundational aspects of size analysis,
  Prof Marko van Eekelen / Dr Olha Shakaravska, Radboud University Nijmegen
* Context oriented programming,
  Dr Pascal Costanza, Vrije Universiteit Brussels
* Multi-core programming,
  Dr Phil Trinder, Heriot-Watt University
* Multi-core compilation,
  Dr Alastair Donaldson, Codeplay Software Ltd
* Principles and Applications of Refinement Types,
  Dr Andrew D. Gordon, Microsoft Research, Cambridge
* Resource aware programming in Hume,
  Prof Greg Michaelson, Heriot-Watt University / Prof Kevin Hammond,
University of St Andrews
* Haskell concurrency  parallelism,
  Dr Satnam Singh, Microsoft Research, Cambridge


Location


The Summer School is at Heriot-Watt University's Riccarton campus, set
in pleasant parkland to the west of Edinburgh, with easy access to the
airport, city and central Scotland
(http://www.hw.ac.uk/welcome/directions.htm).

The Summer School immediately precedes the 2009 International
Conference on Functional Programming
(http://www.cs.nott.ac.uk/~gmh/icfp09.html) and takes place during the
Edinburgh International Festival (http://www.eif.co.uk/) , and the
associated Edinburgh Festival Fringe (http://www.edfringe.com/) and
Edinburgh International Book Festival (http://www.edbookfest.co.uk/)


Steering Committee
~~

Prof Prof Greg Michaelson, Heriot-Watt University (Convenor),
g.michael...@hw.ac.uk
Prof Kevin Hammond, University of St Andrews
Dr Patricia Johann, University of Strathclyde
Prof Philip Wadler, University of Edinburgh


Fee
~~~

Full rate: £400; (free for SICSA students)
Includes: four nights single room, en-suite accommodation with
breakfast, lunch and dinner, plus coffee breaks and session materials.

Day rate: £200; (free for SICSA students)
Includes: lunch, coffee breaks, session materials


Registration of Interest


If you are interested in attending the International Summer School,
please complete the form available from
(http://www.macs.hw.ac.uk/~greg/ISS-AiPL/ISS-AiPL%20register.doc) or
below, and return it to: iss-aipl-regis...@macs.hw.ac.uk


**
International Summer School on Advances in Programming Languages
25th-28th August, 2009
Heriot-Watt University, Edinburgh, Scotland

Registration of Interest

Name:
Address:
Email:
Phone:
SICSA Uni: Yes / No
Rate: Full / Day
Accessibility requirements:
Dietary requirements:

Return to: iss-aipl-regis...@macs.hw.ac.uk
**

[TYPES/announce] CFP: JFP Special Issue on Generic Programming

[Matthew Fluet (ICFP Publicity Chair)]

[ The Types Forum (announcements only), 
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

 OPEN CALL FOR PAPERS

   JFP Special Issue on Generic Programming

   Deadline: 1 October 2009

  http://www.comlab.ox.ac.uk/ralf.hinze/JFP/cfp.html

Scope
-

Generic programming is about making programs more adaptable by making
them more general. Generic programs often embody non-traditional kinds
of polymorphism; ordinary programs are obtained from them by suitably
instantiating their parameters. In contrast to normal programs, the
parameters of a generic program are often quite rich in structure; for
example they may be other programs, types or type constructors,
classes, concepts, or even programming paradigms.

This special issue aims at documenting state-of-the-art research, new
developments and directions for future investigation in the broad
field of Generic Programming. It is an outgrowth of the series of
Workshops on Generic Programming, which started in 1998 and which
continues this year with an ICFP affiliated workshop in
Edinburgh. Participants of the workshops are invited to submit a
suitably revised and expanded version of their paper to the special
issue. The call for papers is, however, open. Other contributions are
equally welcome and are, indeed, encouraged. All submitted papers will
be subjected to the same quality criteria, meeting the standards of
the Journal of Functional Programming.

The special issue seeks original contributions on all aspects of
generic programming including but not limited to

o adaptive object-oriented programming,
o aspect-oriented programming,
o case studies,
o concepts (as in the STL/C++ sense),
o component-based programming,
o datatype-generic programming,
o generic programming with dependent types,
o meta-programming,
o polytypic programming, and
o programming with modules.

Submission details
--

Manuscripts should be unpublished works and not submitted elsewhere.
Revised versions of papers published in conference or workshop
proceedings that have not appeared in archival journals are eligible
for submission.

Deadline for submission:   1 October 2009
Notification of acceptance or rejection:  15 January 2010
Revised version due:  15 March   2010

For submission details, please consult
http://www.comlab.ox.ac.uk/ralf.hinze/JFP/cfp.html
or see the Journal's web page
http://journals.cambridge.org/jfp

Guest Editor


Ralf Hinze
University of Oxford
Computing Laboratory
Wolfson Building, Parks Road, Oxford OX1 3QD, UK.
Telephone: +44 (1865) 610700
Fax: +44 (1865) 283531
Email: ralf.hi...@comlab.ox.ac.uk
WWW: http://www.comlab.ox.ac.uk/ralf.hinze/

---

[TYPES/announce] DEFUN09: Call for Talks Tutorials (co-located w/ ICFP09)

[Matthew Fluet (ICFP Publicity Chair)]

[ The Types Forum (announcements only), 
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

 Call for Talks and Tutorials
 ACM SIGPLAN 2009 Developer Tracks on Functional Programming
  http://www.defun2009.info/
 Edinburgh, Scotland, September 3 and 5, 2009
   The workshop will be held in conjunction with ICFP 2009
  http://www.cs.nott.ac.uk/~gmh/icfp09.html

Important dates

Proposal Deadline: June 5, 2009, 0:00 UTC
Notification: June 19, 2009

DEFUN 2009 invites functional programmers and researchers who know how
to solve problems with functional programming to give talks and lead
tutorials at the The ICFP Developer Tracks.

We want to know about your favorite programming techniques, powerful
libraries, and engineering approaches you've used that the world
should know about and apply to other projects. We want to know how to
be productive using functional programming, write better code, and
avoid common pitfalls.

We invite proposals for presentations in the following categories.

Lightning talks
5- to 10-minute talks that introduce exciting and promising research
or techniques that may be in progress or not yet ready for widespread
use, but that offer a glimpse into the near future of real world
functional programming.
Examples:

* Clustered high performance computing in a functional language
* Making advanced type systems more accessible to working programmers
* How and why we're infiltrating category theory info industry

How-to talks
45-minute how-to talks that provide specific information on how to
solve specific problems using functional programming. These talks
focus on concrete examples, but provide useful information for
developers working on different projects or in different contexts.
Examples:

* How I use Haskell for oilfield simulations.
* How I replaced /sbin/init by a Scheme program.
* How I hooked up my home appliances to an Erlang control system.
* How I got an SML program to drive my BMW.

General language tutorials
Half-day general language tutorials for specific functional languages,
given by recognized experts for the respective languages.

Technology tutorials
Half-day tutorials on techniques, technologies, or solving specific
problems in functional programming.
Examples:

* How to make the best use of specific FP programming techniques
* How to inject FP into a development team used to more
conventional technologies
* How to connect FP to existing libraries / frameworks / platforms
* How to deliver high-performance systems with FP
* How to deliver high-reliability systems with FP

Remember that your audience will include computing professionals who
are not academics and who may not already be experts on functional
programming.

Presenters of tutorials will receive free registration to CUFP 2009.

Submission guidelines

Submit a proposal of 150 words or less for either a 45-minute talk
with a short QA session at the end, or a 300-word-or-less proposal
for a 3-hour tutorial, where you present your material, but also give
participants a chance to practice it on their own laptops.

Some advice:

* Give it a simple and straightforward title or name; avoid fancy
  titles or puns that would make it harder for attendees to figure
  out what you'll be talking about.
* Clearly identify the level of the talk: What knowledge should
  people have when they come to the presentation or tutorial?
* Explain why people will want to attend:
  o Is the language or library useful for a wide range of
attendees?
  o Is the pitfall you're identifying common enough that a
wide range of attendees is likely to encounter it?
* Explain what benefits attendees are expected to take home to
  their own projects.
* For a tutorial, explain how you want to structure the time, and
  what you expect to have attendees to do on their laptops. List
  what software you'll expect attendees to have installed prior to
  coming.

Submit your proposal in plain text electronically to
defun-2009-submissi...@serpentine.com by the beginning of Friday, June
5 2009, Universal Coordinated Time.

Organizers

* Yaron Minsky (Jane Street Capital)
* Ulf Wiger (Erlang Training and Consulting)
* Mike Sperber - co-chair (DeinProgramm)
* Bryan O'Sullivan - co-chair (Linden Lab)

[TYPES/announce] ICFP09 Call for Papers

[Matthew Fluet (ICFP Publicity Chair)]

[ The Types Forum (announcements only), 
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

   Call for Papers
ICFP 2009: International Conference on Functional Programming
  Edinburgh, Scotland, 31 August - 2 September 2009
  http://www.cs.nott.ac.uk/~gmh/icfp09.html
   ** Submission deadline: 2 March 2009 **
 (submission deadline is earlier than usual)

ICFP 2009 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, 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 or
concurrency. Particular topics of interest include
  * Language Design: type systems; concurrency and distribution;
modules; components and composition; metaprogramming; relations to
object-oriented or logic programming; interoperability
  * Implementation: abstract machines; 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; monads; continuations; control; state; effects
  * Transformation and Analysis: abstract interpretation; partial
evaluation; program transformation; program calculation; program
proof
  * 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

The conference also solicits Experience Reports, which are short
papers that provide evidence that functional programming really works
or describe obstacles that have kept it from working in a particular
application.


 What's different this year?
 ~~~

  * The conference dates and the submission deadline are about one
month earlier than usual.

  * Special 'Call for Experience Reports' page, suitable as a target
for posts on blogs and social networks to reach practitioners who
wouldn't normally think about submitting to a conference.  If you
have a blog, etc., please help by pointing your readers to:
http://web.cecs.pdx.edu/~apt/icfp09_cfer.html


   Instructions for authors
   

By Monday, 2 March 2009, 20:00 UTC, submit an abstract of at most 300
words and a full paper of at most 12 pages (4 pages for an Experience
Report), including bibliography and figures. The deadline will be
strictly enforced and papers exceeding the page limits will be
summarily rejected.  Authors have the option to attach supplementary
material to a submission, on the understanding that reviewers may
choose not to look at it.

A submission will be evaluated according to its relevance,
correctness, significance, originality, and clarity. It should explain
its contributions in both general and technical terms, clearly
identifying what has been accomplished, explaining why it is
significant, and comparing it with previous work. The technical
content should be accessible to a broad audience. Functional Pearls
and Experience Reports are separate categories of papers that need not
report original research results and must be marked as such at the
time of submission. Detailed guidelines on both categories are below.

Each submission must adhere to SIGPLAN's republication policy, as
explained on the web. Violation risks summary rejection of the
offending submission.

Proceedings will be published by ACM Press. Authors of accepted
submissions are expected to transfer the copyright to
ACM. Presentations will be videotaped and released online if the
presenter consents by signing an additional permission form at the
time of the presentation.  Released videos will be included along with
the conference proceedings in the ACM Digital Library and may also be
placed on a host such as YouTube or Google Video.

Formatting:
~~~
Submissions must be in PDF format printable in black and white on US
Letter sized paper and interpretable by Ghostscript. If this
requirement is a hardship, make contact with the program chair at
least one week before the deadline. ICFP proceedings 

[TYPES/announce] Workshop on Generic Programming: Call for Participation (co-located w/ ICFP08)

[Matthew Fluet (ICFP Publicity Chair)]

[ The Types Forum (announcements only), 
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

Dear all,

the Workshop on Generic Programming is only a few days away: 20th
September 2008 (http://www.regmaster.com/conf/icfp2008.html).

== Invited talk: The Generic Paradigm
== Lambert Meertens (Utrecht University)

== We have reserved 20 minutes for *lightning talks*. If you plan to
== attend and if you would like to give a short talk (about half-baked,
== exciting, new stuff) please drop me a short note. Slots will be
== reserved on a first-come-first-serve basis.

Looking forward to seeing you in Victoria, Ralf Hinze



   CALL FOR PARTICIPATION

 Workshop on Generic Programming 2008

Victoria, Canada, 20th September 2008

 http://www.comlab.ox.ac.uk/ralf.hinze/wgp2008/cfp.{html,pdf,ps,txt}

 The Workshop on Generic Programming is sponsored by ACM SIGPLAN
 and forms part of ICFP 2008.  Previous Workshops on Generic
 Programming have been held in Marstrand (affiliated with MPC),
 Ponte de Lima (affiliated with MPC), Nottingham (informal
 workshop), Dagstuhl (IFIP WG2.1 Working Conference), Oxford
 (informal workshop), Utrecht (informal workshop), and Portland
 (affiliated with ICFP).



Preliminary program
---

9:00 - 10:00, Session Chair: Ralf Hinze (University of Oxford)

Welcome

Invited talk: The Generic Paradigm
Lambert Meertens (Utrecht University)

10:30 - 12:00, Session Chair: Jeremy Gibbons (University of Oxford)

A Functional Model-View-Controller Software Architecture for
Command-oriented Programs
Alley Stoughton (Kansas State University)

A Lightweight Approach to Datatype-Generic Rewriting
Thomas van Noort (Radboud University Nijmegen), Alexey Rodriguez,
Stefan Holdermans (Utrecht University), Johan Jeuring (Utrecht
University and Open University of the Netherlands), Bastiaan
Heeren (Open University of the Netherlands)

Lightning talks

13:30 - 15:00, Session Chair: Ralf Hinze (University of Oxford)

Report from the program chair
Ralf Hinze (University of Oxford)

Scala for Generic Programmers
Bruno C. d. S. Oliveira, Jeremy Gibbons (University of Oxford)

A Comparison of C++ Concepts and Haskell Type Classes
Jean-Philippe Bernardy, Patrik Jansson, Marcin Zalewski, Sibylle
Schupp, Andreas Priesnitz (Chalmers University of Technology and
University of Gothenburg)

Lightning talks

15:30 - 17:30, Session Chair: Patrik Jansson (Chalmers University of
Technology and University of Gothenburg)

Polytypic Programming in Coq
Wendy Verbruggen, Edsko de Vries, Arthur Hughes (Trinity College
Dublin)

Bialgebra Views: A Way for Polytypic Programming to Cohabit with
Data Abstraction
Pablo Nogueira, Juan Jose Moreno-Navarro (Universidad Politecnica
de Madrid)

Discussion

[TYPES/announce] ICFP08 Call for Participation

[Matthew Fluet (ICFP Publicity Chair)]

[ The Types Forum (announcements only), 
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

=
Call for Participation

The 13th ACM SIGPLAN International Conference
on Functional Programming (ICFP 2008)

http://www.icfpconference.org/icfp2008

  Victoria, BC, Canada, 22-24 September 2008
=

ICFP 2008 provides a forum for researchers and developers to hear
about the latest work on the design, implementations, principles, and
uses of functional programming. The conference covers the entire
spectrum of work, from practice to theory, including its peripheries.

Preliminary program:
 * http://www.icfpconference.org/icfp2008/schedule.html
 * Invited speakers:
   + Butler Lampson, Microsoft Research;
 Lazy and Speculative Execution in Computer Systems
   + Olivier Danvy, University of Aarhus;
 Defunctionalized Interpreters for Higher-Order Languages
   + Mark Jones, Portland State University;
 Polymorphism and Page Tables -- Systems Programming From a
 Functional Programmer's Perspective

Schedule including related workshops:
 * Sep 20: ACM SIGPLAN Workshop on Generic Programming
 * Sep 20: ACM SIGPLAN Workshop on Mechanizing Metatheory
 * Sep 20: ACM SIGPLAN Workshop on Scheme and Functional Programming
 * Sep 21: ACM SIGPLAN Workshop on ML
 * Sep 21: ACM SIGPLAN Functional and Declarative Programming in Education
 * Sep 22-24: ICFP08
 * Sep 25: ACM SIGPLAN Haskell Symposium
 * Sep 25: Functional Programming Developer Tracks
 * Sep 26: Commercial Users of Functional Programming
 * Sep 27: ACM SIGPLAN Erlang Workshop
 * Sep 27: Functional Programming Developer Tracks

Registration information:
 * http://www.regmaster.com/conf/icfp2008.html
 * Early registration deadline: August 20, 2008

Conference hotel accommodation information:
 * http://www.deltahotels.com/groups/online/VIC/acm.php
 * Conference rate deadline: August 18, 2008
 * Wiki page to coordinate room-sharing:
   http://www.icfpconference.org/pmwiki/pmwiki.php?n=Main.ICFP08RoomShare


Conference organizers:
 * General Chair: James Hook (Portland State University)
 * Program Chair: Peter Thiemann (Universität Freiburg)
 * Local Arrangements Chair: George Tzanetakis (University of Victoria)
 * Workshop Co-Chairs: Michael Sperber (DeinProgramm)
   and Graham Hutton (University of Nottingham)
 * Programming Contest Co-Chairs: John Reppy (University of Chicago)
   and Tim Sheard (Portland State University)
 * Publicity Chair: Matthew Fluet (Toyota Technological Institute at Chicago)

[TYPES/announce] ICFP2008 Call for Poster proposals

[Matthew Fluet (ICFP Publicity Chair)]

[ The Types Forum (announcements only), 
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

ICFP 2008 poster session
September 21, 2008
Call for presentation proposals

ICFP 2008 will feature a poster session for researchers and
practitioners, including students.  The session will provide friendly
feedback for work that is in gestation or ongoing, as well as
opportunities to meet each other and exchange ideas.  We welcome poster
submissions on all ICFP topics, especially presentations of

  - applications of and to functional programming;
  - recent work presented at more distant venues; and
  - ongoing work, whether or not submitted to ICFP.

There will be no formal proceedings, but presenters will be invited to
submit working notes, demo code, and other materials to supplement their
abstract and poster.  These materials will be released informally on a
Web page dedicated to the poster session.  An accepted submission is not
intended to replace conference or journal publication.

Persons interested in presenting a poster are invited to submit a
one-page abstract in SIGPLAN conference style
http://www.acm.org/sigs/sigplan/authorInformation.htm
to the Web site
https://www.softconf.com/s08/icfp08-posters/submit.html
by June 30, 2008.  The program committee will review the submissions
for relevance and interest, and notify the authors by July 14, 2008.
Accepted posters must be presented by the authors in person on Sunday,
September 21, 2008.

Important dates:
Submission: Monday, June 30, 2008
Notification: Monday, July 14, 2008
Presentation: Sunday, September 21, 2008

Program committee:
Benjamin Pierce (University of Pennsylvania)
Colin Runciman (University of York)
Chung-chieh Shan (Rutgers University)

[TYPES/announce] Haskell08: Call for papers (co-located w/ ICFP08)

[Matthew Fluet (ICFP Publicity Chair)]

[ The Types Forum (announcements only), 
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

   Haskell 08

   ACM SIGPLAN 2008 Haskell Symposium
   Victoria, British Columbia, Canada
Thursday, 25th September, 2008

 FIRST CALL FOR PAPERS

 http://haskell.org/haskell-symposium/2008

   The Haskell Symposium 2008 is part of the 2008 International Conference
   on Functional Programming (ICFP) as an associated ACM SIGPLAN sponsored
   symposium.

   The purpose of the Haskell Symposium is to discuss experience with
   Haskell, and future developments for the language. The scope of the
   symposium includes all aspects of the design, semantics, theory,
   application, implementation, and teaching of Haskell. Topics of
   interest include, but are not limited to, the following:
 * Language Design, with a focus on possible extensions and
   modifications of Haskell as well as critical discussions of the
   status quo;
 * Theory, in the form of a formal treatment of the semantics of the
   present language or future extensions, type systems, and
   foundations for program analysis and transformation;
 * Implementations, including program analysis and transformation,
   static and dynamic compilation for sequential, parallel, and
   distributed architectures, memory management as well as foreign
   function and component interfaces;
 * Tools, in the form of profilers, tracers, debuggers,
   pre-processors, and so forth;
 * Applications, Practice, and Experience, with Haskell for scientific
   and symbolic computing, database, multimedia and Web applications,
   and so forth as well as general experience with Haskell in
   education and industry;
 * Functional Pearls, being elegant, instructive examples of using
   Haskell.

   Papers in the latter two categories need not necessarily report
   original research results; they may instead, for example, report
   practical experience that will be useful to others, re-usable
   programming idioms, or elegant new ways of approaching a problem. The
   key criterion for such a paper is that it makes a contribution from
   which other practitioners can benefit. It is not enough simply to
   describe a program!

   Before 2008, the Haskell Symposium was known as the Haskell
   Workshop.  The name change reflects the steady increase of
   influence of the Haskell Workshop on the wider community, as well
   as an increasing numbers of high quality submissions making the
   acceptance process highly competitive.  Previously, Haskell
   Workshops have been held in La Jolla (1995), Amsterdam (1997),
   Paris (1999), Montreal (2000), Firenze (2001), Pittsburgh (2002),
   Uppsala (2003), Snowbird (2004), Tallinn (2005),
   Portland, Oregon (2006), Freiburg (2007).

Submission Details

 * Submission Deadline: Monday, June 23rd 2008
  (9:00 am, Samoa Standard Time, UTC -11)
 * Author Notification: Friday, July 18th 2008
 * Final Papers Due: Monday, July 28th 2008

   Submitted papers should be in portable document format (PDF), formatted
   using the ACM SIGPLAN style guidelines
   (http://www.acm.org/sigs/sigplan/authorInformation.htm). The length is
   restricted to 12 pages, and the font size 9pt. Each submission must
   adhere to SIGPLAN's republication policy, as explained on the web.
   Violation risks summary rejection of the offending submission.

   Paper submissions can be made via the easychair webpage
   http://www.easychair.org/conferences/?conf=haskell08

   Accepted papers will be published by the ACM and will appear in the ACM
   Digital Library.

   If there is sufficient demand, we will try to organize a time slot for
   system or tool demonstrations. If you are interested in demonstrating a
   Haskell related tool or application, please send a brief demo proposal
   to Andy Gill, [EMAIL PROTECTED]

Links

 * http://haskell.org/haskell-symposium, the permanent homepage of the
   Haskell Symposium.
 * http://haskell.org/haskell-symposium/2008, the 2008 Haskell
   Symposium web page.
 * http://www.icfpconference.org/icfp2008, the ICFP 2008 web page.

Program Committee

 * Arthur Baars, Instituto Tecnologico de Informatica, Valencia, Spain
 * Jeremy Gibbons, Oxford University, UK
 * Andy Gill, Galois, USA (Program Chair)
 * William Harrison, University of Missouri, Columbia, USA
 * Roman Leshchinskiy, University of New South Wales, Australia
 * Bernie Pope, University of Melbourne, Australia
 * Colin Runciman, University of York, UK
 * Tim Sheard, Portland State University, USA
 * Mary Sheeran, Chalmers University of Technology, Sweden
 * Satnam Singh, Microsoft Research, UK
 * Wouter Swierstra, Nottingham University, UK
 * Varmo Vene, University of Tartu, Estonia

[TYPES/announce] DEFUN08: Call for Talks Tutorials (co-located w/ ICFP08)

[Matthew Fluet (ICFP Publicity Chair)]

[ The Types Forum (announcements only), 
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

 Call for Talks and Tutorials
 ACM SIGPLAN 2008 Developer Tracks on Functional Programming
http://www.deinprogramm.de/defun-2008/
 Victoria, BC, Canada, 25, 27 September, 2008
   The workshop will be held in conjunction with ICFP 2008.
   http://www.icfpconference.org/icfp2008/

Important dates

Proposal Deadline: June 27, 2008, 0:00 UTC
Notification:  July 14, 2008

DEFUN 2008 invites functional programmers who know how to solve
problems with functional prorgamming to give talks and lead tutorials
at the The ICFP Developer Tracks.

We want to know about your favorite programming techniques, powerful
libraries, and engineering approaches you've used that the world
should know about and apply to other projects. We want to know how to
be productive using functional programming, write better code, and
avoid common pitfals.

We invite proposals for presentations in the following categories:

How-to talks: 45-minute how-to talks that provide specific
  information on how to solve specific problems using functional
  programming. These talks focus on concrete examples, but provide
  useful information for developers working on different projects or in
  different contexts.

  Examples:
  - How I made Haskell an extension language for SAP R/3.
  - How I replaced /sbin/init by a Scheme program.
  - How I hooked up my home appliances to an Erlang control system.
  - How I got an SML program to drive my BMW.

General language tutorials
  Half-day general language tutorials for specific functional
  languages, given by recognized experts for the respective languages.

Technology tutorials Half-day tutorials on techniques, technologies,
  or solving specific problems in functional programming

  such as:
  - how to make the best use of specific FP programming techniques
  - how to inject FP into a development team used to more conventional
technologies
  - how to connect FP to existing libraries / frameworks / platforms
  - how to deliver high-performance systems with FP
  - how to deliver high-reliability systems with FP

Remember that your audience will include computing professionals who
are not academics and who may not already be experts on functional
programming.

Presenters of tutorials will receive free registration to ICFP 2008.

Submission guidelines

Submit a proposal of 150 words or less for either a 45-minute talk
with a short QA session at the end, or a 300-word-or-less proposal
for a 3-hour tutorial, where you present your material, but also give
participants a chance to practice it on their own laptops.

Some advice:
- Give it a simple and straightforward title or name; avoid fancy
  titles or puns that would make it harder for attendees to figure out
  what you'll be talking about.
- Clearly identify the level of the talk: What knowledge should people
  have when they come to the presentation or tutorial?
- Explain why people will want to attend:
  is the language or library useful for a wide range of attendees? Is
  the pitfall you're identifying common enough that a wide range of
  attendees is likely to encounter it?
- Explain what benefits attendees are expected to take home to their
  own projects.
- For a tutorial, explain how you want to structure the time, and what
  you expect to have attendees to do on their laptops. List what
  software you'll expect attendees to have installed prior to coming.

Submit your proposal in plain text electronically to
defun-2008-submission-AT-deinprogramm.de by the beginning of Friday,
June 27, Universal Coordinated Time.

Organizers
Kathleen Fisher ATT Labs
Simon Peyton Jones  Microsoft Research
Mike Sperber (co-chair) DeinProgramm
Don Stewart (co-chair)  Galois

[TYPES/announce] ICFP07 Reminder: registration deadline

[Matthew Fluet (ICFP Publicity Chair)]

[ The Types Forum (announcements only), 
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

=
 Final Call for Participation

The 12th ACM SIGPLAN International Conference
on Functional Programming (ICFP 2007)

 http://www.informatik.uni-bonn.de/~ralf/icfp07.html
 http://proglang.informatik.uni-freiburg.de/ICFP2007

 Freiburg, Germany, 1-3 October 2007
=

  * Early Registration Deadline: September 7, 2007 *


ICFP 2007 provides a forum for researchers and developers to hear
about the latest work on the design, implementations, principles, and
uses of functional programming. The conference covers the entire
spectrum of work, from practice to theory, including its peripheries.

Schedule including related workshops:
 *  30 Sep: ACM SIGPLAN Haskell Workshop
 *  30 Sep: ACM SIGPLAN Workshop on Scheme and Functional Programming
 * 1-3 Oct: ICFP07
 *   4 Oct: ACM SIGPLAN Commercial Users of Functional Programming
 *   4 Oct: ACM SIGPLAN Workshop on Mechanizing Metatheory
 *   5 Oct: ACM SIGPLAN Erlang Workshop
 *   5 Oct: ACM SIGPLAN Workshop on ML
 *   5 Oct: ACM SIGPLAN Programming Languages meets Program Verification

[TYPES/announce] ICFP07 Call for Participation

[Matthew Fluet (ICFP Publicity Chair)]

[ The Types Forum (announcements only), 
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]

=
Call for Participation

The 12th ACM SIGPLAN International Conference
on Functional Programming (ICFP 2007)

 http://www.informatik.uni-bonn.de/~ralf/icfp07.html

 Freiburg, Germany, 1-3 October 2007
=

ICFP 2007 provides a forum for researchers and developers to hear
about the latest work on the design, implementations, principles, and
uses of functional programming. The conference covers the entire
spectrum of work, from practice to theory, including its peripheries.

Preliminary program:
 * http://www.informatik.uni-bonn.de/~ralf/schedule.html
 * Invited speakers:
   + John Hughes (Chalmers University of Technology)
   + Frank Pfenning (Carnegie Mellon University)
   + John Lloyd (Australian National University)
 * The Program committee has *deliberately* created extra breaks so as
   to give participants more time to talk with colleagues.

Schedule including related workshops:
 *  30 Sep: ACM SIGPLAN Haskell Workshop
 *  30 Sep: ACM SIGPLAN Workshop on Scheme and Functional Programming
 * 1-3 Oct: ICFP07
 *   4 Oct: ACM SIGPLAN Commercial Users of Functional Programming
 *   4 Oct: ACM SIGPLAN Workshop on Mechanizing Metatheory
 *   5 Oct: ACM SIGPLAN Erlang Workshop
 *   5 Oct: ACM SIGPLAN Workshop on ML
 *   5 Oct: ACM SIGPLAN Programming Languages meets Program Verification

Registration information:
 * http://proglang.informatik.uni-freiburg.de/ICFP2007/registration.shtml
 * Early registration deadline: September 7, 2007

Accommodations information:
 * http://proglang.informatik.uni-freiburg.de/ICFP2007/accommodation.shtml
 * Conference reservation/rate deadline: September 1, 2007
 * September/October is Freiburg's main tourist season; participants
   are advised to book rooms as early as possible.

Conference organizers:
 * General Chair: Ralf Hinze (Universität Bonn)
 * Program Chair: Norman Ramsey (Harvard University)
 * Local Arrangements Chair: Peter Thiemann (Universität Freiburg)
 * Workshop Co-Chairs: Graham Hutton (University of Nottingham)
   and Matthias Blume (Toyota Technological Institute at Chicago)
 * Programming Contest Chair: Johan Jeuring (Universiteit Utrecht)
 * Publicity Chair: Matthew Fluet (Toyota Technological Institute at Chicago)

[TYPES/announce] ICFP07 Accepted Papers

[Matthew Fluet (ICFP Publicity Chair)]

[ The Types Forum (announcements only), 
 http://lists.seas.upenn.edu/mailman/listinfo/types-announce ]


  Accepted Papers
   ICFP 2007: International Conference on Functional Programming
http://www.informatik.uni-bonn.de/~ralf/icfp07.html
Freiburg, Germany, 1-3 October 2007

The ICFP 2007 Program Chair and Committee are pleased to announce that
the following papers have been accepted for the conference.

Additional information regarding the final program, invited speakers,
and registration will be forthcoming.  However, the Local Arrangements
Chair offers the following advice regarding hotel reservations:

* As September and October is Freiburg's main tourist season, it is
  important that participants book hotel rooms early.  The blocks of
  hotel rooms reserved for ICFP participants will be held until
  August 1.  It is expected that many downtown hotels will be fully
  booked at the time of the conference.  [However, there should be
  little to no penalty for cancelling a hotel room reservation after
  August 1.]

More details regarding accommodation and travel may be obtained from
the ICFP 2007 Local Information webpage:
http://proglang.informatik.uni-freiburg.de/ICFP2007/


  Accepted papers
  ~~~

A Generic Usage Analysis with Subeffect Qualifiers
   by Jurriaan Hage, Stefan Holdermans, Arie Middelkoop

Experience Report: A Haskell interpreter for CellML
   by Jonathan Cooper, Steve McKeever

A type directed translation of MLF to System-F
   by Daan Leijen

A Type System for Recursive Modules
   by Derek Dreyer

Adding Delimited and Composable Control to a Production Programming
 Environment
   by Matthew Flatt, Gang Yu, Robert Bruce Findler, Matthias Felleisen

Bidirectionalization Transformation based on Automatic Derivation of View
 Complement Functions
   by Kazutaka Matsuda, Zhenjiang Hu, Keisuke Nakano, Makoto Hamana,
Masato Takeichi

Experience Report: Building an Eclipse-based IDE for Haskell
   by Leif Frenzel

Compiling with Continuations, Continued
   by Andrew J. Kennedy

Constructor specialisation for Haskell programs
   by Simon Peyton Jones

Evaluating High-Level Distributed Language Constructs
   by Jan Nystrom, Phil Trinder, David King

Extensible Pattern Matching via a Lightweight Language Extension
   by Don Syme, Gregory Neverov, James Margetson

Faster laziness using dynamic pointer tagging
   by Simon Marlow, Alexey Rodriguez, Simon Peyton Jones

Feedback Directed Implicit Parallelism
   by Tim Harris, Satnam Singh

Finger Trees in Russell
   by Matthieu Sozeau

Functional Pearl: The Great Escape
   by David Herman

Experience Report: Functional Programming in C-Rules
   by Jeremy Wazny

Inductive Reasoning about Effectful Data Types
   by Andrzej Filinski, Kristian Stoevring

iTasks: Executable Specifications of Interactive Work Flow Systems for the
Web
   by Rinus Plasmeijer, Peter Achten, Pieter Koopman

Lazy Call-By-Value Evaluation
   by Frank Huch, Bernd Brassel, Sebastian Fischer, Michael Hanus,
German Vidal

McErlang: A Model Checker for a Distributed Functional Programming Language
   by Lars-Åke Fredlund, Hans Svensson

On Barron and Strachey's Cartesian Product Function
   by Michael Spivey, Olivier Danvy

Ott: Effective Tool Support for the Working Semanticist
   by Peter Sewell, Francesco Zappa Nardelli, Scott Owens, Gilles Peskine,
Thomas Ridge, Susmit Sarkar, Rok Strnisa

Relating Complexity and Precision in Control Flow Analysis
   by David Van Horn, Harry Mairson

Experience Report: Scheme in Commercial Web Application Development
   by Noel Welsh, David Gurnell

Stream Fusion: From Lists to Streams to Nothing at All
   by Duncan Coutts, Roman Leshchinskiy, Don Stewart

Tangible Functional Programming
   by Conal Elliott

Termination Analysis and Call Graph Construction for Higher-Order Functional
 Programs
   by Damien Sereni

The Portable R6RS Syntax System
   by Abdulaziz Ghuloum, R. Kent Dybvig

Experience Report: The Reactis Validation Tool
   by Steve Sims, Daniel C. DuVarney

Type-safe Higher-order Channels in ML-like Languages
   by Sungwoo Park

User-Friendly Functional Programming for Web Mashups
   by Rob Ennals, David Gay

Experience Report: Using Functional Programming to Manage a Linux
Distribution
   by Clifford Beshers, David Fox, Jeremy Shaw