Tom's Declarative Languages Blog

Postdoctoral positions at Ghent University

2012-01-13T09:37:00.000+01:00

Get in touch if you are interested in applying for a postdoctoral position in the area of programming languages (computer science).

Sixpostdoctoral positions in Ghent University’s Faculty of Science will beavailable with effect from 1 October 2012, for a duration of 3 years.

Profile:

The candidate:

· holds a Ph.D. degree based on a doctoraldissertation, preferentially in (Natural) Sciences (the Ph.D. diploma must havebeen awarded before the date of appointment to the position i.c. 1^st October 2012);

· conducts research activities in one of theresearch areas that are covered by the faculty of Sciences; this must clearlyappear from current research work and from a research plan for the coming yearsthat demonstrates a synergy with at least one of the research groups of theFaculty of Sciences;

· has relevant scientific publications innational and international journals that are widely distributed and that applya peer review procedure to the submitted manuscripts;

· has actively participated in national andinternational scientific meetings that are relevant to the field of study;

· Should dispose of adequate didactic andcommunicative skills;

· Communications or oral presentations atscientific meetings and sojourns for study purposes in foreign countries serveas an additional recommendation;

· Experience with guidance of practical exercisesand master theses, serve as an additional recommendation.

Content of the position:

The successful candidate is expected to:

· carry out scientific research in one of the researchareas that are covered by the faculty of Sciences (minimally 90% of the timehas to be devoted to scientific research);

· contribute to the academic education activitiesof the host department;

· contribute to the supervision of master thesesand doctoral students;

· elaborate and write applications and reports ofresearch projects;

· supervise and support scientific projects;

· contribute to the services provided by the hostdepartment.

The governing languageat Ghent University is Dutch. However, research is primarily conducted inEnglish. Persons who do not speak Dutch as a native language are very welcometo apply.

Applications must besent by registered mail to the Personnel Office, Sint-Pietersnieuwstraat 25,9000 Ghent, at the latest on 29 February 2012. Applications should include aCV, proof of suitability (e.g., copies of the applicant’s diplomas), adescription of the current research and a research project plan (2 pages). Aduly filled in application form that can be downloaded from https://edit.ugent.be/we/enmust be sent as excel-file to decaan.we@ugent.be.

ICLP 2012: Call for Papers

2011-12-22T14:09:00.002+01:00

CALL FOR PAPERS

28th International Conference on Logic Programming

Budapest, Hungary, September 4-8, 2012

http://www.cs.bme.hu/iclp2012/

The International Conference on Logic Programming is the premier venue for presenting research in logic programming. ICLP 2012 will take place in Budapest, honouring the important contribution that the Hungarian logic programming community has given to this field. The ICLP technical program will include presentations of accepted papers, invited talks, advanced tutorials and panels, a special session on most influential papers, the doctoral consortium, the programming contest, and several workshops. Contributions are sought in all areas of logic programming, including but not restricted to:

Theory: Semantic Foundations, Formalisms, Non-Monotonic Reasoning, Knowledge Representation.
Implementation: Compilation, Memory Management, Virtual Machines, Parallelism.
Environments: Program Analysis, Transformation, Validation, Verification, Debugging, Profiling, Testing.
Language Issues: Concurrency, Objects, Coordination, Mobility, Higher Order, Types, Modes, Assertions, Programming Techniques.
Related Paradigms: Abductive/Inductive/Constraint Logic Programming, Answer-Set Programming.
Applications: Databases, Data Integration and Federation, Software Engineering, Natural Language Processing, (Semantic) Web, Agents, Artificial Intelligence, Bioinformatics, Declarative Networking.

There are four broad categories for submissions:

technical papers describe technically sound, innovative ideas that can advance the state of the art of logic programming;
application papers present real-world applications of logic programming;
system and tool papers focus on the novelty, practicality, usability and general availability of the systems and tools described; and
technical communications aim at describing recent developments, new projects, and other materials that are not ready for publication as standard papers.

Important Dates

Workshop Proposals: January 29, 2012
Paper registration (abstract): March 11, 2012
Submission deadline: March 18, 2012
Notification to Authors (first round): April 28, 2012
Notification to Authors (second round): June 10, 2012
Camera-ready LIPIcs copy due: June 10, 2012
Camera-ready TPLP copy due: July 1, 2012
Conference: September 4-8, 2012

General Chair

Peter Szeredi (Budapest Univ. of Technology and Economics)

Program Committee Chairs

Agostino Dovier (Univ. of Udine)
Vitor Santos Costa (Univ. of Porto)

Workshop Chair

Mats Carlsson (SICS, Sweden)

Doctoral Consortium Chairs

Marco Gavanelli (Univ. of Ferrara)
Stefan Woltran (T.U. Wien)

Programming Contest

Tom Schrijvers (Univ. of Gent)

Publicity Chair

Gergely Lukacsy (Cisco Systems Inc.)

Web Manager

Janos Csorba (Budapest Univ. of Technology and Economics)

Program Committee

Elvira Albert (U.C. Madrid)
Sergio Antoy (Portland State Univ.)
Marcello Balduccini (Kodak Res. Labs)
Manuel Carro (U.P. Madrid)
Michael Codish (Ben Gurion Univ.)
Veronica Dahl (Simon Fraser Univ.)
Marina De Vos (Univ. of Bath)
Alessandro Dal Palu’ (Univ. of Parma)
Bart Demoen (K.U. Leuven)
Thomas Eiter (T.U. Wien)
Esra Erdem (Sabanci Univ.)
Thom Fruehwirth (Univ. of Ulm)
Andrea Formisano (Univ. of Perugia)
Maria Garcia de la Banda (Monash Univ.)
Marco Gavanelli (Univ. of Ferrara)
Hai-Feng Guo (Univ. of Nebraska, Omaha)
Gopal Gupta (Univ. of Texas, Dallas)
Katsumi Inoue (National Inst. of Informatics, Japan)
Angelika Kimmig (K.U. Leuven)
Joohyung Lee (Arizona State Univ.)
Evelina Lamma (Univ. of Ferrara)
Nicola Leone (Univ. of Calabria)
Yuliya Lierler (Univ. of Kentucky)
Boon Thau Loo (Univ. of Pennsylvania)
Michael Maher (R.R.I., Sidney)
Alessandra Mileo (DERI, Galway)
Jose Morales (U.P. Madrid)
Enrico Pontelli (New Mexico State Univ.)
Gianfranco Rossi (Univ. of Parma)
Beata Sarna-Starosta (Cambian, Vancouver)
Torsten Schaub (Univ. of Potsdam)
Tom Schrijvers (Univ. of Gent)
Fernando Silva (Univ. of Porto)
Tran Cao Son (New Mexico State Univ.)
Terrance Swift (Univ. Nova de Lisboa)
Peter Szeredi (Budapest Univ. of Tech.)
Francesca Toni (I.C. London)
Mirek Truszczynski (Univ. of Kentucky)
German Vidal (U.P. of Valencia)
Stefan Woltran (T.U. Wien)
Neng-Fa Zhou (CUNY, New York)
For other information see Conference Web Site

OCaml @ Incubaid

2011-12-14T21:02:00.001+01:00

Nicolas Trangez and Romain Slootmaekers were so kind to give a guest lecture on real-world functional programming in my Functional and Logic Programming course. They gave an overview of their experience (and success!) with OCaml in building distributed storage systems at Incubaid.

Their slides are available here:
http://www.slideshare.net/eikke/realworld-functional-programming-incubaid

FLOPS 2012: Final Call for Papers and Deadline Extension

2011-12-05T11:35:00.001+01:00

_EXTENDED SUBMISSION DEADLINE : December 16, 2011_

*Eleventh International Symposium on Functional and Logic Programming (FLOPS 2012)*
May 23-25, 2012
Kobe, Japan
[http://www.org.kobe-u.ac.jp/flops2012/]
_EXTENDED SUBMISSION DEADLINE : December 16, 2011_

FLOPS is a forum for research on all issues concerning declarative
programming, including functional programming and logic programming,
and aims to promote cross-fertilization and integration between the
two paradigms. Previous FLOPS meetings were held in Fuji Susono
(1995), Shonan Village (1996), Kyoto (1998), Tsukuba (1999), Tokyo
(2001), Aizu (2002), Nara (2004), Fuji Susono (2006), Ise (2008),
and Sendai (2010).

Topics
======
FLOPS solicits original papers in all areas of functional and logic
programming, including (but not limited to):
- Declarative Pearls: new and excellent declarative programs with
    illustrative applications.
- Language issues: language design and constructs, programming methodology,
    integration of paradigms, interfacing with other languages, type systems,
    constraints, concurrency and distributed computing.
- Foundations: logic and semantics, rewrite systems and narrowing, type
    theory, proof systems.
- Implementation issues: compilation techniques, memory management, program
    analysis and transformation, partial evaluation, parallelism.
- Applications: case studies, real-world applications, graphical user
    interfaces, Internet applications, XML, databases, formal methods and model
    checking.

The proceedings will be published as an LNCS volume. The proceedings
of the previous meeting (FLOPS 2010) were published as LNCS 6009.

PC co-Chairs
============
- Tom Schrijvers (Ghent University, Belgium)
- Peter Thiemann (University of Freiburg, Germany)

PC Members
==========
- Salvador Abreu (University of Evora, Portugal)
- Thorsten Altenkirch (University of Nottingham, UK)
- Sebastian Brand (NICTA, Australia)
- Giuseppe Castagna (CNRS Univ Paris 7, France)
- Sebastian Fischer (Germany)
- Marco Gavanelli (University of Ferrara, Italy)
- Joxan Jaffar (National University of Singapore, Singapore)
- Barry Jay (University of Sydney, Australia)
- Andy King (University of Kent, UK)
- Claude Kirchner (INRIA, France)
- Neelakantan R. Krishnaswami (Microsoft Cambridge, UK)
- Yulya Lierler (University of Kentucky, USA)
- Keiko Nakata (Tallinn University of Technology, Estonia)
- Peter Schneider-Kamp (University of Southern Denmark, Denmark)
- Olin Shivers (Northeastern University, USA)
- Paul Tarau (University of Northern Texas, USA)
- Kazunori Ueda (Waseda University, Japan)
- Meng Wang (Chalmers Technical University, Sweden)

General Chair and Local co-Chairs
=================================
- Naoyuki Tamura (Kobe University, Japan)
- Mutsunori Banbara (Kobe University, Japan)
- Katsutoshi Hirayama (Kobe University, Japan)

Submission
==========
Submissions must be unpublished and not submitted for publication
elsewhere. Work that already appeared in unpublished or informally
published workshops proceedings may be submitted. Submissions should
fall into one of the following categories:
- Regular research papers: they should describe new results and will be
    judged on originality, correctness, and significance.
- System descriptions: they should contain a link to a working system and
    will be judged on originality, usefulness, and design.
Submissions must be written in English and can be up to 15 pages
long, though pearls are typically considerably shorter. Authors are
required to use LaTeX2e and the Springer llncs class file, available at
[http://www.springer.de/comp/lncs/authors.html].

Regular research papers should be supported by proofs and/or
experimental results. In case of lack of space, this supporting
information should be made accessible otherwise (e.g., a link to a
web page, or an appendix). Papers should be submitted electronically
at [https://www.easychair.org/conferences/?conf=flops2012].

Important Dates
===============
- Submission deadline : December 16, 2011    (EXTENDED)
- Author notification : February 3, 2012
- Camera-ready copy : March 2, 2012

Place and Related Events
========================
Takikawa Memorial Hall, Kobe University,
1-1 Rokkodai, Nada, Kobe 657-8501 Japan.

The 23rd International Conference on Rewriting Techniques and
Applications (RTA 2012) and satellite workshops including WFLP 2012
will be held in the week after FLOPS at Nagoya, Japan.

Some Previous FLOPS
===================
- FLOPS 2010, Sendai: [http://www.kb.ecei.tohoku.ac.jp/flops2010/]
- FLOPS 2008, Ise: [http://www.math.nagoya-u.ac.jp/~garrigue/FLOPS2008/]
- FLOPS 2006, Fuji Susono: [http://hagi.is.s.u-tokyo.ac.jp/FLOPS2006/]

Sponsors
========
- Japan Society for Software Science and Technology (JSSST) SIGPPL

In Cooperation with
===================
- ACM SIGPLAN
- Asian Association for Foundation of Software (AAFS)
- Association for Logic Programming (ALP)

PhD Position in Purely Functional Programming

2011-11-30T09:47:00.001+01:00

The Programming Languages Group of Ghent University invites applicants for a PhD position. This position centers around the modular treatment of side-effects in purely functional programs and models. It is part of the project "Modular handling of effects in purely functional programs and models" under the direction of Tom Schrijvers.

The successful applicant has a master degree in Computer Science or equivalent. Ideally, she/he will also have a strong, documented interest in doing research. Strong problem-solving and programming skills are essential. Prior knowledge of purely functional programming (e.g., Haskell) and models of side-effects (e.g., monads) is an advantage.

The PhD position is for 4 years. It starts between January and October 2012. The position is a fully-funded post. The salary is compatible with other Belgian PhD rates and among the better ones in Europe and abroad.

See here for application details.

FLOPS 2012: 2nd call for papers

2011-11-22T11:47:00.001+01:00

                       Second Call For Papers
                       =====================

*Eleventh International Symposium on Functional and Logic
Programming (FLOPS 2012)*
May 23-25, 2012
Kobe, Japan
[http://www.org.kobe-u.ac.jp/flops2012/]
_Submission deadline : December 9, 2011_

FLOPS is a forum for research on all issues concerning declarative
programming, including functional programming and logic programming,
and aims to promote cross-fertilization and integration between the
two paradigms. Previous FLOPS meetings were held in Fuji Susono
(1995), Shonan Village (1996), Kyoto (1998), Tsukuba (1999), Tokyo
(2001), Aizu (2002), Nara (2004), Fuji Susono (2006), Ise (2008),
and Sendai (2010).

Topics
======
FLOPS solicits original papers in all areas of functional and logic
programming, including (but not limited to):
- Declarative Pearls: new and excellent declarative programs with
   illustrative applications.
- Language issues: language design and constructs, programming methodology,
   integration of paradigms, interfacing with other languages, type systems,
   constraints, concurrency and distributed computing.
- Foundations: logic and semantics, rewrite systems and narrowing, type
   theory, proof systems.
- Implementation issues: compilation techniques, memory management, program
   analysis and transformation, partial evaluation, parallelism.
- Applications: case studies, real-world applications, graphical user
   interfaces, Internet applications, XML, databases, formal methods and model
   checking.

The proceedings will be published as an LNCS volume. The proceedings
of the previous meeting (FLOPS 2010) were published as LNCS 6009.

PC co-Chairs
============
- Tom Schrijvers (Ghent University, Belgium)
- Peter Thiemann (University of Freiburg, Germany)

PC Members
==========
- Salvador Abreu (University of Evora, Portugal)
- Thorsten Altenkirch (University of Nottingham, UK)
- Sebastian Brand (NICTA, Australia)
- Giuseppe Castagna (CNRS Univ Paris 7, France)
- Sebastian Fischer (Germany)
- Marco Gavanelli (University of Ferrara, Italy)
- Joxan Jaffar (National University of Singapore, Singapore)
- Barry Jay (University of Sydney, Australia)
- Andy King (University of Kent, UK)
- Claude Kirchner (INRIA, France)
- Neelakantan R. Krishnaswami (Microsoft Cambridge, UK)
- Yulya Lierler (University of Kentucky, USA)
- Keiko Nakata (Tallinn University of Technology, Estonia)
- Peter Schneider-Kamp (University of Southern Denmark, Denmark)
- Olin Shivers (Northeastern University, USA)
- Paul Tarau (University of Northern Texas, USA)
- Kazunori Ueda (Waseda University, Japan)
- Meng Wang (Chalmers Technical University, Sweden)

General Chair and Local co-Chairs
=================================
- Naoyuki Tamura (Kobe University, Japan)
- Mutsunori Banbara (Kobe University, Japan)
- Katsutoshi Hirayama (Kobe University, Japan)

Submission
==========
Submissions must be unpublished and not submitted for publication
elsewhere. Work that already appeared in unpublished or informally
published workshops proceedings may be submitted. Submissions should
fall into one of the following categories:
- Regular research papers: they should describe new results and will be
   judged on originality, correctness, and significance.
- System descriptions: they should contain a link to a working system and
   will be judged on originality, usefulness, and design.
Submissions must be written in English and can be up to 15 pages
long, though pearls are typically considerably shorter. Authors are
required to use LaTeX2e and the Springer llncs class file, available at
[http://www.springer.de/comp/lncs/authors.html].

Regular research papers should be supported by proofs and/or
experimental results. In case of lack of space, this supporting
information should be made accessible otherwise (e.g., a link to a
web page, or an appendix). Papers should be submitted electronically
at [https://www.easychair.org/conferences/?conf=flops2012].

Important Dates
===============
- Submission deadline : December 9, 2011
- Author notification : February 3, 2012
- Camera-ready copy : March 2, 2012

Place and Related Events
========================
Takikawa Memorial Hall, Kobe University,
1-1 Rokkodai, Nada, Kobe 657-8501 Japan.

The 23rd International Conference on Rewriting Techniques and
Applications (RTA 2012) and satellite workshops including WFLP 2012
will be held in the week after FLOPS at Nagoya, Japan.

Some Previous FLOPS
===================
- FLOPS 2010, Sendai: [http://www.kb.ecei.tohoku.ac.jp/flops2010/]
- FLOPS 2008, Ise: [http://www.math.nagoya-u.ac.jp/~garrigue/FLOPS2008/]
- FLOPS 2006, Fuji Susono: [http://hagi.is.s.u-tokyo.ac.jp/FLOPS2006/]

Sponsors
========
- Japan Society for Software Science and Technology (JSSST) SIGPPL

In Cooperation with
===================
- ACM SIGPLAN
- Asian Association for Foundation of Software (AAFS)
- Association for Logic Programming (ALP)

PhD Position in Rule-based Programming Systems

2011-11-10T13:28:00.003+01:00

The Programming Languages Group of Ghent University invites applicants for a PhD position. This position centers around the development of efficient rule-based programming systems and is part of our new project "Constraint Programming for advanced joins in rule-based programming languages". The project is under the direction of Tom Schrijvers.

The successful applicant has a master degree in Computer Science or equivalent. Ideally, she/he will also have a strong, documented interest in doing research. Strong problem-solving and programming skills are essential. Prior knowledge of rule-based/query/logic/constraint programming languages and/or database theory is an advantage, but not required.

The PhD position is for 4 years. It starts between January and October 2012. The position is a fully-funded post. The salary is compatible with other Belgian PhD rates and among the better ones in Europe and abroad.

Ghent University has position 89 in the Shanghai Academic Ranking of World Universities - 2011. It is located in the beautiful city of Ghent, which is one of Lonely Planet's top 10 cities for 2011. For more information on life as a PhD researcher at UGent see here.

Please direct inquiries and applications, preferably by e-mail, to:

Professor Tom Schrijvers Vakgroep Toegepaste Wiskunde en Informatica Universiteit Gent Krijgslaan 281 S9 WE02 B-9000 Gent, BELGIUM E-mail: tom.schrijvers@ugent.be

Notice of interest (including motivation and CV) should be received as soon as possible. The start date is determined in consultation with the selected candidate.

CONSTRAINTS JOURNAL - Special Issue on Modeling and Reformulation

2011-09-08T09:44:00.000+02:00

First Call for Papers

CONSTRAINTS JOURNAL -
Special Issue on Modeling and Reformulation


A central aspect of using any reasoning or optimization tools to solve problems 
is expressing the problem within the language of the tool. While Constraint 
Programming is pursuing the goal of simple declarative problem modeling ("model 
and press 'solve'"), it is still often the case that building a high-performance
model for a problem represents a significant effort in modeling, re-modeling, 
and reformulation. Similar challenges are encountered in related areas such as 
mixed-integer programming and SAT solving.

In honour of the Tenth edition of the International Workshop on Constraint 
Modeling and Reformulation (ModRef 2011 - http://aenas.arfcd.com/modref11/), 
the Constraints journal solicits submissions for a special issue. While we 
encourage submissions of extended versions of papers that have appeared in 
previous ModRef workshops, this is an open call with no such requirement.


Topics of Interest
-------------------
These include, but are not limited to:

- Problem Models
   - novel, improved problem formulations
   - novel problems that can be formulated and successfully solved as CSPs

- Automated Modeling and Reformulation
   - Automated generation of implied constraints.
   - Automated generation of symmetry-breaking constraints.
   - Automated generation of constraints to exploit dominance relations.
   - Automated generation of relaxations. 

- Constraint Modeling Languages
   - Abstraction in constraint languages.
   - Abstract variable domains.
   - Abstraction in search control.
   - Automated refinement.

- Interaction between Modeling/Reformulation and Search

- Interaction between Modeling/Reformulation and Propagation

- Applications of Automated Modeling Systems

- Overviews of Modeling and Reformulation research in other closely related 
  areas such as mathematical programming and SAT solving


Paper Forms
-----------
We are looking for papers that fit into any of the formats that Constraints 
publishes. In particular:

- Survey papers - papers that review modeling and reformation within CP or other
  areas that are of particular interest to the CP community (e.g., mathematical
  programming, SAT). If you plan to submit such a paper, please contact the 
  guest editors as soon as possible as we would like to avoid submissions of 
  overlapping survey papers.
- Application papers - papers the describe real-life applications of CP where 
  modeling and reformulation play a central role in the success of the 
  application.
- Letters - short papers presenting that makes a significant contribution but 
  does not require a full-size journal paper.

We are also interested in more speculative papers that, for example, extrapolate
current research and practice to indicate trends, opportunities, and research 
topics over the next 10 years (e.g., ten challenge problems in modeling and 
reformulation).


Submission and Refereeing
-------------------------
All submission will be refereed to the usual standards of the Constraints 
journal. Final decisions on acceptance will be made by the guest editors in 
consultation with the editor-in-chief.

Submissions will be made through the Constraints online submission
system at http://cons.edmgr.com. Please select the article type "SI:
Modeling and Reformulation" at submission time.


Guest Editors
--------------
Andrea Rendl, Austrian Institute of Technology
J. Christopher Beck, University of Toronto


Important Dates
---------------
Submissions: February 1, 2012
Results of First Round of Reviewing: May 1, 2012
Final versions: Summer 2012

FLOPS 2012: 1st Call for Papers

2011-08-15T08:48:00.000+02:00

First Call For Papers

=====================

*Eleventh International Symposium on Functional and Logic Programming (FLOPS 2012)*

May 23-25, 2012

Kobe, Japan

[http://www.org.kobe-u.ac.jp/flops2012/]

_Submission deadline : December 9, 2011_

FLOPS is a forum for research on all issues concerning declarative

programming, including functional programming and logic programming,

and aims to promote cross-fertilization and integration between the

two paradigms. Previous FLOPS meetings were held in Fuji Susono

(1995), Shonan Village (1996), Kyoto (1998), Tsukuba (1999), Tokyo

(2001), Aizu (2002), Nara (2004), Fuji Susono (2006), Ise (2008),

and Sendai (2010).

Topics

======

FLOPS solicits original papers in all areas of functional and logic

programming, including (but not limited to):

- Declarative Pearls: new and excellent declarative programs with

illustrative applications.

- Language issues: language design and constructs, programming methodology,

integration of paradigms, interfacing with other languages, type systems,

constraints, concurrency and distributed computing.

- Foundations: logic and semantics, rewrite systems and narrowing, type

theory, proof systems.

- Implementation issues: compilation techniques, memory management, program

analysis and transformation, partial evaluation, parallelism.

- Applications: case studies, real-world applications, graphical user

interfaces, Internet applications, XML, databases, formal methods and model

checking.

The proceedings will be published as an LNCS volume. The proceedings

of the previous meeting (FLOPS 2010) were published as LNCS 6009.

PC co-Chairs

============

- Tom Schrijvers (Ghent University, Belgium)

- Peter Thiemann (University of Freiburg, Germany)

PC Members

==========

- Salvador Abreu (University of Evora, Portugal)

- Thorsten Altenkirch (University of Nottingham, UK)

- Sebastian Brand (NICTA, Australia)

- Giuseppe Castagna (CNRS Univ Paris 7, France)

- Sebastian Fischer (Germany)

- Marco Gavanelli (University of Ferrara, Italy)

- Joxan Jaffar (National University of Singapore, Singapore)

- Barry Jay (University of Sydney, Australia)

- Andy King (University of Kent, UK)

- Claude Kirchner (INRIA, France)

- Neelakantan R. Krishnaswami (Microsoft Cambridge, UK)

- Yulya Lierler (University of Kentucky, USA)

- Keiko Nakata (Tallinn University of Technology, Estonia)

- Peter Schneider-Kamp (University of Southern Denmark, Denmark)

- Olin Shivers (Northeastern University, USA)

- Paul Tarau (University of Northern Texas, USA)

- Kazunori Ueda (Waseda University, Japan)

- Meng Wang (Chalmers Technical University, Sweden)

General Chair and Local co-Chairs

=================================

- Naoyuki Tamura (Kobe University, Japan)

- Mutsunori Banbara (Kobe University, Japan)

- Katsutoshi Hirayama (Kobe University, Japan)

Submission

==========

Submissions must be unpublished and not submitted for publication

elsewhere. Work that already appeared in unpublished or informally

published workshops proceedings may be submitted. Submissions should

fall into one of the following categories:

- Regular research papers: they should describe new results and will be

judged on originality, correctness, and significance.

- System descriptions: they should contain a link to a working system and

will be judged on originality, usefulness, and design.

Submissions must be written in English and can be up to 15 pages

long, though pearls are typically considerably shorter. Authors are

required to use LaTeX2e and the Springer llncs class file, available at

[http://www.springer.de/comp/lncs/authors.html].

Regular research papers should be supported by proofs and/or

experimental results. In case of lack of space, this supporting

information should be made accessible otherwise (e.g., a link to a

web page, or an appendix). Papers should be submitted electronically

at [https://www.easychair.org/conferences/?conf=flops2012].

Important Dates

===============

- Submission deadline : December 9, 2011

- Author notification : February 3, 2012

- Camera-ready copy : March 2, 2012

Place and Related Events

========================

Takikawa Memorial Hall, Kobe University,

1-1 Rokkodai, Nada, Kobe 657-8501 Japan.

The 23rd International Conference on Rewriting Techniques and

Applications (RTA 2012) and satellite workshops including WFLP 2012

will be held in the week after FLOPS at Nagoya, Japan.

Some Previous FLOPS

===================

- FLOPS 2010, Sendai: [http://www.kb.ecei.tohoku.ac.jp/flops2010/]

- FLOPS 2008, Ise: [http://www.math.nagoya-u.ac.jp/~garrigue/FLOPS2008/]

- FLOPS 2006, Fuji Susono: [http://hagi.is.s.u-tokyo.ac.jp/FLOPS2006/]

Report of the 18th Prolog Programming Contest

2011-07-14T20:43:00.001+02:00

Update: the problems

Pictures of the contest

First, for those of you who don't know: In the Prolog Programming Contest we lock up teams of Prolog programmers in a room for 2 hours with 5 challenges. Each team has up to 3 members and one laptop. The team that solves most challenges in the least amount of time is the winner.

Now, like every year, participants could not wait to sign up for this year's contest. Really, no extortion or heavy handling was required.

Well, admittedly, there were the usual excuses for not participating, like:

I already do this for a day job, or
It would not be fair to the other participants, or
I am too old for this (now more about that later).

There are better ways to get out of participating ... if you can afford them. I won't mention a petrol state professor who sent his students, instead of himself.

Anyway, 9 teams showed up -- 1 more than last year -- constituting 24 participants.
We had

2 Leuven teams (again),
1 Viking team,
1 Italian team,
1 Texas team,
1 standardization team,
1 "old boys" team -- see being old is no excuse,
and 2 more mixed teams.

Unfortunately, last year's winners, Jan Wielemaker and his team, could not come
to Lexington.

A few words of thanks are in order. There are more people involved in making the Prolog Programming Contest happen than you think. I am very grateful to all of them. I would like to thank the program chairs, John Gallagher and Michael Gelfond, for inviting the contest to ICLP 2011 and providing a slot in their program. Thanks to the general chairs, Mirek and Marek, for providing us with the chairs, tables, the room and the many power sockets. Finally, thanks to Jael for helping me run the contest and for telling the participants in the kindest possible way that their answers were wrong.

I realize I say this every year: the problems were hard this year - but they were also doable. We had poultry, fast food and Joe the Plumber made an appearance.
Every problem was solved by at least one team. Moreover, every team solved at least one problem -- congratulations to all the participants! Before we move on to this year's winners, I want to say: there is no shame if you don't win the contest, there is only shame if you don't participate.

We have had a slow but consistent trickle of answer submissions throughout the contest. All teams know they got one answer right. Several teams were told they got 2 answers right. One team has won, but does not know yet that it got 3 answers right. At the very end of the contest, in the last minute, there were 2 submissions that did not get feedback.

This year's Prolog system of choice is Ciao Prolog. Congratulation to this year’s winners, who have shown that you are never too old to win: Antonio Porto, Michael Leuschel and Manuel Hermenegildo.

So, that's it for this year. I hope you've all enjoyed. See you next year!

Mobility Grant for Postdocs from China, Vietnam, Cambodia, Myanmar, Indonesia and Thailand

2011-06-29T20:09:00.003+02:00

Are you a South-East Asian postdoc in the area of programming languages interested to spend some time at Ghent University in Belgium? Then contact me.

For more information, see http://www.lotus.ugent.be/

Call 4 of Lotus, the EU - South-East Asian Mobility Project: only for POSTDOC!
Call 4 will be closed on Friday September 2nd, 2011 at 11am local Belgian time.

Lotus is an Erasmus Mundus Action Two Partnership (EMA2) of European and South-East Asian Higher Education Institutions (HEI) and Associations aiming at fostering mutual enrichment and better understanding between the EU and South-East Asia (China, Vietnam, Cambodia, Myanmar, Indonesia, Thailand), through the exchange of persons, knowledge and skills at higher education level and to co-operate in postdoc mobility.

ModRef2011 - Call for Papers

2011-05-10T11:22:00.002+02:00

The 10th International Workshop on
Constraint Modelling and Reformulation (ModRef 2011)
http://aenas.arfcd.com/modref11

To be held at the 17th International Conference on the
Principles and Practice of Constraint Programming (CP 2011)
Perugia, Italy, Monday 12 September 2011

*** Extended Deadline: 1 July 2011 ***

AIMS AND SCOPE

Constraint Programming (CP) is a powerful technology to model and
solve combinatorial problems, which are ubiquitous in academia and
industry. The last ten years or so have witnessed significant research
devoted to modelling and solving problems with constraints. CP is now
a mature field and has been successfully used for tackling a wide
range of real-life complex applications. However, such a technology is
currently accessible to only a small number of experts. For CP to be
more widely used by non-experts, more research effort is needed in
order to ease the use of the CP technology. We solicit original papers
that contribute to widen the use of the CP technology.

Workshop topics include (but are not limited to):
* Application papers describing interesting problems and
interesting ways to model them;
* Contributions to understanding modelling that could guide the
manual or automatic formulation of models;
* Identification of the criteria that should be used in
evaluating models and the design of pragmatic techniques that
facilitate the choice and possibly combination among
alternative models;
* Design of higher-level modelling languages;
* Automatic reformulation techniques.

PROGRAMME COMMITTEE

Andrea Rendl (chair) (Austria)
J. Christopher Beck (co-chair) (Canada)

Alan M. Frisch (UK)
Stefan Heinz (Germany)
Brahim Hnich (Turkey)
Jimmy Lee (China)
Ian Miguel (UK)
Michaela Milano (Italy)
Nina Narodytska (Australia)
Justin K. Pearson (Sweden)
Tom Schrijvers (Belgium)
Helmut Simonis (Ireland)
Pascal Van Hentenryck (USA)
Mark Wallace (Australia)

IMPORTANT DATES

Submission deadline Friday 24 June 2011
Author notification Sunday 17 July 2011
Camera-Ready Copy deadline Friday 19 August 2011
Workshop Monday 12 September 2011

SUBMISSION

Submissions must be formatted in the Lecture Notes in Computer Science
(LNCS) style and must not exceed 15 pages. Submissions of shorter
papers, including position papers, are welcome.

Papers must be submitted in PDF format using EasyChair:
https://www.easychair.org/conferences/?conf=modref11

All submissions will be reviewed and those that are well written and
make a worthwhile contribution to the topic of the workshop will be
accepted for publication in the workshop proceedings. The proceedings
will be available electronically at CP 2011. At least one author of
each accepted paper must attend the workshop. To attend the workshop
it is necessary to pay the workshop fees.

More info is available at the workshop web-site:
http://aenas.arfcd.com/modref11

WLPE 2011: Call for Papers

2011-04-25T10:09:00.001+02:00

----------------------------------------------------------------------
21st Workshop on Logic-based methods in Programming Environments

Affiliated with ICLP 2011
July 10, Lexington, Kentucky, USA
http://imada.sdu.dk/~petersk/WLPE2011/
----------------------------------------------------------------------

NEWS

* keynote given by Manuel Hermenegildo (see INVITED SPEAKER)
* early registration is open until May 31 (see CONFERENCE VENUE)
* EPTCS acceptance for refereed post-proceedings (see SUBMISSIONS)

OBJECTIVES

The goal of the 21s Workshop on Logic-based methods in Programming
Environments (WLPE 2011) is to be a informal venue for presentation
and discussion of research on logic-based methods and tools which
support program development and analysis. In this way, the workshop
tries to bridge the gaps between different communities interested
and active in logic-based tools for programming.

In addition to papers describing more conceptual and theoretical work,
we explicitly also welcome papers describing the implementation of,
and experience with, such tools.

The 21st Workshop on Logic-based methods in Programming Environments
continues the series of successful workshops held in Ohio, USA (1989),
Eilat, Israel (1990), Paris, France (1991), Washington D.C., USA (1992),
Vancouver, Canada (1993), Santa Margherita Ligure, Italy (1994),
Portland, USA (1995), Leuven, Belgium and Port Jefferson, USA (1997),
Las Cruces, USA (1999), Paphos, Cyprus (2001),
Copenhagen, Denmark (2002), Mumbai, India (2003),
Saint Malo, France (2004), Sitges (Barcelona), Spain (2005),
Seattle, USA (2006), Porto, Portugal (2007), Udine, Italy (2008),
Pasadena, USA (2009), and Edinburgh, UK (2010).

We hope to attain the same friendly atmosphere as in past workshops,
which enabled fruitful exchanges leading to joint research and
subsequent publications.

TOPICS

Areas particularly relevant to the workshop include (but are not
limited to):

* static and dynamic analysis
* debugging and testing
* program verification and validation
* code generation from specifications
* termination analysis
* reasoning on occurs-check freeness and determinacy
* profiling and performance analysis
* type and mode analysis
* shape, point-to and escape analysis
* module systems
* optimization tools
* program understanding
* refactoring
* logical meta-languages

Authors who are interested in taking part in the workshop, but are
unsure if their work falls within its scope, are warmly invited to
contact the organizers and obtain suitable advice.

SUBMISSIONS

We encourage the submission of original research in the area as well as
relevant results that have been submitted, rejected, or accepted elsewhere
as long as they are relevant for the WLPE community.

All papers must be written in English and should not exceed 15 pages.
We welcome also shorter submissions, e.g., extended abstracts and
short papers, of at least 3 pages.

There will be no formal reviewing and no formal proceedings. The accepted papers will be made available electronically before the workshop.
In case there is a sufficient number of original publications,
we will invite authors to refereed post-proceedings in EPTCS.

Papers should be submitted electronically via the submission page:

http://www.easychair.org/conferences/?conf=wlpe2011

Final versions should be created using LaTeX and the style file
eptcs.cls (http://style.eptcs.org/). Alternatively, easychair.cls (http://www.easychair.org/coolnews.cgi) can be used for the informal proceedings.

IMPORTANT DATES

Paper submission April 29
Notification May 16
Final versions due May 28
Workshop date July 10

INVITED SPEAKER

The keynote speaker will be Manuel Hermenegildo from Universidad
Politecnica de Madrid and University of New Mexico.

CONFERENCE VENUE

The workshop will be held as a satellite workshop of ICLP 2011
organized by the Computer Science Department of the University of
Kentucky in Lexington, Kentucky, USA.

Registration fees will be discounted until May 31. Registration
is now possible at:

http://www.cs.uky.edu/iclp2011/iclp11Registration.html

PROGRAM COMMITTEE

Michael Codish Ben-Gurion University, Israel
Carsten Fuhs RWTH Aachen, Germany
John Gallagher University of Roskilde, Denmark
Samir Genaim Complutense University of Madrid, Spain
Petra Hofstedt TU Berlin, Germany
Andy King University of Kent, UK
Ulrich Neumerkel TU Wien, Austria
Peter Schneider-Kamp University of Southern Denmark, Denmark
Tom Schrijvers Ghent University, Belgium
Alexander Serebrenik TU Eindhoven, The Netherlands
Wim Vanhoof University of Namur, Belgium
German Vidal Universitat Politecnica de Valencia, Spain

“Sandwich”-type doctoral grants for candidates from developing countries

2011-02-13T14:12:00.002+01:00

Are you a PhD candidate in a developing country who would like to spend 2 years at the University of Ghent (Belgium) doing research on programming languages?

Read the full details here. If you are interested, get in touch with me asap and we may be able to work out an application. The deadline for the submission of applications is 15 March 2011, at 5 p.m.

Vlaamse Programmeerwedstrijd 2011

2011-01-21T12:03:00.004+01:00

De Vlaamse Programmeerwedstrijd, intussen al een vaste waarde bij de programmerende Vlaamse jongeren en studenten, is aan zijn derde editie toe. Deze gaat door in Kortrijk op 23 maart.

Tijdens de VPW lossen de deelnemers (in teams van 3) in een beperkte tijd van 3 uren zoveel mogelijk problemen op in een van de ondersteunde programmeertalen, namelijk C, C++, Java, Haskell, PHP, Prolog, Python, Ruby, Visual Basic, C#, Pascal of Scheme.
Leerlingen uit het secundair onderwijs en uit het hoger onderwijs (hogeschool en universiteit) kunnen deelnemen aan de Vlaamse Programmeerwedstrijd, net als doctoraatstudenten en mensen uit de industrie.
Binnen elke categorie krijgen de drie beste programmeerteams een prijs. Dankzij onze sponsors kunnen we een aanzienlijke prijzenpot aanbieden. Bovendien gaat niemand met lege handen naar huis.

Voor meer informatie en inschrijving kan je op de VPW site terecht.

Symposium: Functional Programming in Industry

2010-10-28T10:57:00.002+02:00

At the occasion of BelHac, the first Belgian Haskell Hackathon from 5-7 Nov 2010, the Ghent Functional Programming Group is organizing a symposium on "Functional Programming in Industry", to which you are cordially invited.

The symposium is is held on Friday, November 5th at 17:00 in the Jozef Plateauzaal in the Plateau building of Ghent University (Jozef Plateaustraat 22, 9000 Gent).

The program is as follows:

Duncan Coutts (Well-Typed, http://www.well-typed.com/, BelHac sponsor) who will be talking on how Well-Typed are providing consultancy services for Haskell, a pure functional programming language.
Romain Slootmaekers (Incubaid, http://www.incubaid.com, BelHac sponsor) who will be talking on the use of functional programming in Incubaid, a company based in the Ghent area.
Don Stewart (Galois, http://www.galois.com) who will be talking on how Galois is using Haskell in many of their projects, including government contracts.

The talks will be followed by a reception.

Please register.

Doctoral Position

2010-08-05T11:40:00.000+02:00

I have a doctoral position available:

DOCTORAL POSITION

Programming Languages Group
Department of Applied Mathematics and Computer Science
University of Ghent, Belgium

The new Programming Languages Group at the University of Ghent is looking for
doctoral research candidates in the area of Datalog.
The position concerns research related to language development, program
optimization, integration with constraint solvers, problem modeling,
refactoring, profiling, debugging, ... Close collaboration with our US-based
industrial partner is expected.

Applicants should have a masters degree in Computer Science or equivalent.
Experience in Datalog, logic programming (Prolog, ASP, ...), databases or
constraint programming is an asset.

Appointment to the doctoral position will be for the period of one year
initially with possibility for extension to four years ending in a Ph.D. The
salary is compatible with the departmental rates for doctoral research fellows.

Please direct inquiries and applications, preferably by e-mail, to:

Professor Tom Schrijvers
Vakgroep Toegepaste Wiskunde en Informatica
Universiteit Gent
Krijgslaan 281-S9,
B-9000 Gent, BELGIUM

E-mail: datalog.ugent@gmail.com

Notice of interest (including motivation and CV) should be received as soon as
possible. Review of applications begins as of August 15, 2010, and the start date
is determined in consultation with the selected candidate.

BelHac 2010

2010-07-30T10:35:00.001+02:00

We are very pleased to officially announce an international
Hackaton in Ghent, Belgium, on 5, 6 and 7 November 2010.

If you are interested in attending, we have put some information on
the wiki. We will soon put up more details about transportation,
accommodation and food. (And Belgian beer, of course!) You can
register here.

WHEN

Friday November 5: 2pm - 7pm
Saturday November 6: 10am - 6pm
Sunday November 7: 10am - 6pm

WHERE

In “The Therminal”, in Ghent, Belgium. Please see the wiki for more details.

We hope to see you in Belgium!

The GhentFPG organizing committee.

Report of the 17th Prolog Programming Contest

2010-07-19T11:41:00.007+02:00

In the Prolog Programming Contest we lock up teams of Prolog programmers in a room for a short time with 5 challenges. Each team has 3 members and one laptop. The team that solves most challenges in the least amount of time is the winner.

Participants eagerly presented themselves: 8 teams of 3 people showed up.

We had

2 Leuven teams,

1 Low Countries team,

3 country teams: one each from Italy, Denmark and Germany,

2 mixed teams
- an Austrian-Portugese-US team with Neng-Fa Zhou, and
- a Danish-English-Italian team with Marco Gavanelli.

Last years winners were represented by Peter Van Weert in a Leuven team.

It is at least as much fun running the contest as it is participating. Many teams have learned from last year's techniques. Swapping around the keyboard like mad and reading the problem description pages on both sides simultaneously were definitely popular again.

You learn a lot of things running the contest. Practicing in advance is very effective, but it's not too late to learn Prolog during the contest. Knowing your team mates intimately is no guarantee for success, nor is having won last year.

I am grateful to quite a few people who have made the Prolog Programming Contest possible. Firstly, thanks to Bart Demoen for founding the contest series and running it for so many years; also thanks for supplying one particularly nasty problem description. Secondly, I would like to thank the FLoC organizers and ICLP chairs, Manuel Hermenegildo and Torsten Schaub, for providing us with an excellent venue with many power sockets and making the contest an integral part of the programme. Finally, thanks to Gerda Janssens for helping me run the contest very smoothly.

Now, on to the ranking. This year's contest was much more challenging than last year's. Three out of eight teams have not submitted any correct solution; one of these did not submit anyting. The time pressure was immense: solve 5 problems in 90 minutes rather than the usual 120. But Prolog is great at rapid prototyping, right? Unfazed by this time pressure, most teams ignored the 4 easy problems and went straight for the hardest... without success. The most successful teams were those that remembered in time to also look at the other problems.

Having 2 solutions was enough to make the top 3 this year. The team that came in third, is the team of Jon Sneyers, Peter Van Weert and Dean Voets.

Then, there are two teams left, just 2 minutes apart, also with 2 correct solutions. These are the teams of Neng-Fa Zhou and Jan Wielemaker. Clearly being a Prolog system implementer gives you an edge in the contest. Congratulation to this year's winners: Jan Wielemaker, Paolo Pilozzi and Peter Biener. The winners' Prolog system of choice is SWI-Prolog.

I hope you enjoyed it.

Tom

The problem descriptions are available here.

PADL 2011

2010-07-16T12:39:00.000+02:00

13th International Symposium on
Practical Aspects of Declarative Languages (PADL 2011)

http://www.dcc.fc.up.pt/PADL-2011

Austin, Texas, USA, January 24-25, 2011
Co-located with ACM POPL'11

Conference Description
======================

Declarative languages build on sound theoretical bases to provide
attractive frameworks for application development. These languages
have been successfully applied to many different real-world
situations, ranging from data base management to active networks to
software engineering to decision support systems.

New developments in theory and implementation have opened up new
application areas. At the same time, applications of declarative
languages to novel problems raise numerous interesting research
issues. Well-known questions include 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 forum for researchers and practitioners to present
original work emphasizing novel applications and implementation
techniques for all forms of declarative concepts, including,
functional, logic, constraints, etc. 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

PADL'11 welcomes new ideas and approaches pertaining to
applications and implementation of declarative languages. In this
occasion PADL is co-located, as traditionally, with ACM POPL, which
will be held immediately following PADL, January 26-28. The symposium
will be held in Austin, Texas, USA.

Important Dates and Submission Guidelines
==============================

===========

Abstract Submission: September 1, 2010
Paper Submission: September 8, 2010
Notification: October 11, 2010
Camera-ready: November 1, 2010
Symposium: January 24-25, 2011

Authors should submit an electronic copy of the full paper in PDF
using the Springer LNCS format. The submission will be done through
EasyChair conference system. If electronic submission is impossible,
please contact the program chairs for information on how to submit
hard copies. All submissions must be original work written in
English. Submissions must be unpublished and not submitted for
publication elsewhere. Work that already appeared in unpublished or
informally published workshops proceedings may be submitted. PADL'11
will accept both technical and application papers:

* Technical papers must describe original, previously unpublished
research results. Technical papers must not exceed 15 pages in
Springer LNCS format.
* 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 will be published in the Springer-Verlag conference
proceedings, and will be presented in a separate session.
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. The limit for application papers is 3 pages in
Springer LNCS format.

Most Practical Paper Award
==========================

The Most Practical Paper award will be given to the submission that
is judged by the program committee to be the best in terms of
practicality, originality, and clarity of presentation. The program
committee may choose not to make an award, or to make multiple awards.

Program Committee
=================

Ricardo Rocha, University of Porto, Portugal (co-chair)
John Launchbury, Galois, USA (co-chair)
Agostino Dovier, University of Udine, Italy
André Santos, Federal University of Pernambuco, Brazil
Bryan O'Sullivan, Serpentine Green Design, USA
Byron Cook, Microsoft Research, UK
C. R. Ramakrishnan, SUNY Stony Brook, USA
Germán Puebla, Technical University of Madrid, Spain
Konstantinos Sagonas, National Technical University of Athens, Greece
Maria Garcia de la Banda, Monash University, Australia
Martin Erwig, Oregon State University, USA
Neal Glew, Intel Corporation, USA
Neng-Fa Zhou, CUNY Brooklyn College, USA
Salvador Abreu, University of Évora, Portugal
Sukyoung Ryu, Advanced Institute of Science and Technology, Korea
Tom Schrijvers, Katholieke Universiteit Leuven, Belgium
Xavier Leroy, INRIA, France
Yitzhak Mandelbaum, AT&T Labs Research, USA

Contacts
========

For additional information about papers and submissions, please
contact the Program Chairs:

Ricardo Rocha
CRACS @ INESC-Porto LA & University of Porto, Portugal
Email: ricroc@dcc.fc.up.pt

John Launchbury
Galois, USA
Email: john@galois.com

With the Cooperation of
=======================

The University of Texas at Dallas
ACM SIGPLAN

===================================

Haskell 2010, Final Call for Papers

2010-06-04T22:35:00.000+02:00

Haskell 2010

ACM SIGPLAN Haskell Symposium 2010
Baltimore MD, United States
30th September, 2010

FINAL CALL FOR PAPERS

http://www.haskell.org/haskell-symposium/2010/

The ACM SIGPLAN Haskell Symposium 2010 will be co-located with the
2010 International Conference on Functional Programming (ICFP), in
Baltimore, Maryland.

The purpose of the Haskell Symposium is to discuss experiences 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:

* Language Design, with a focus on possible extensions and
modifications of Haskell as well as critical discussions of the
status quo;

* Theory, such as formal treatments 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 suchlike;

* Functional Pearls, being elegant, instructive examples of using
Haskell;

* Applications, Practice, and Experience, using 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.

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, reusable
programming idioms, or elegant new ways of approaching a
problem. (More advice appears on the symposium webpage.)
The key criterion for such a paper is that it makes a
contribution from which other Haskellers 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 both the steady increase of
influence of the Haskell Workshop on the wider community, as well as
the increasing number of high quality submissions. The selection
process is highly competitive. After eleven Haskell Workshops
between 1995 and 2007, the first Haskell Symposium was held in
Victoria in 2008, and the second in Edinburgh in 2009.

Submission Details

* Submission Deadline: Monday, 14th June 2010, 15:00 UTC
* Author Notification: Monday, 12th July 2010
* Final Papers Due : Monday, 2nd August 2010

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 text
should be in a 9pt font in two columns; the length is restricted to
12 pages, except for "Applications, Practice, and Experience"
papers, which are restricted to 6 pages. Each submission must
adhere to SIGPLAN's republication policy, as explained on the web.
Violation risks summary rejection of the offending submission.
Accepted papers will be published by the ACM and will appear in the
ACM Digital Library.

In addition, we solicit proposals for system demonstrations, based
on running (perhaps prototype) software rather than necessarily on
novel research results. Proposals are limited to 2-page abstracts,
in the same ACM format as papers, and should explain why a
demonstration would be of interest to the Haskell community. They
will be assessed for relevance by the PC; accepted proposals will
be published on the Symposium website, but not formally published
in the proceedings.

Links

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

Programme Committee

* Jeremy Gibbons, University of Oxford (chair)
* James Cheney, University of Edinburgh
* Duncan Coutts, Well-Typed LLP
* Sharon Curtis, Oxford Brookes University
* Fritz Henglein, Kobenhavns Universitet
* Tom Schrijvers, Katholieke Universiteit Leuven
* Chung-chieh Shan, Rutgers - The State University of New Jersey
* Martin Sulzmann, Informatik Consulting Systems AG
* Wouter Swierstra, Vector Fabrics
* Peter Thiemann, Universitaet Freiburg
* Andrew Tolmach, Portland State University
* Malcolm Wallace, University of York

Brief report of 1st FPUG meeting in Ghent

2010-04-03T14:56:00.004+02:00

The 1ste Functional Programming Users Group meeting in Ghent took place on April 1 -- not a prank! There were about 30 attendants, not bad for a first meeting: plenty of students, PhD students and postdocs from Ghent University as well as few outsiders.

We had a full program:

Jeroen Janssen - Welcome and short introduction to FP
Jasper Van der Jeugt - BlazeHtml: a blazingly fast Html generator in Haskell
Tom Schrijvers - The Monad Zipper
Romain Slootmaekers - Functional Programming at Amplidata
Insightful: how to convince the management that Ocaml is better than C++.
Denis Defreyne, Pieter De Baets - An introduction to PHunctional Programming
Functional Programming in PHP (April 1 after all)

More info and slides are available from the Ghent FPG page. I'm looking forward to the next edition. If you are around, then do join us.

The Monad Zipper

2010-03-23T10:00:00.007+01:00

Bruno Oliveira and I are working on a functional pearl called The Monad Zipper (*). You know how dealing with monad transformers can be quite awkward -- especially when developing highly modular programs where every component comes with its own effects?
Well, we bring relief in this situation by applying Huet's zipper to a type-level data structure: the monad stack.

We're submitting to ICFP on April 2, and would greatly appreciate your feedback on the current draft. Please let us know what you think of the presented approach, the clarity and style of writing, examples of situations where you could have used the monad zipper, ...

(*) not to be confused with the zipper monad

Update: By popular request the source code is now available to play with. Mind, it's extracted right out of our literate Haskell code -- the paper is the documentation.

Update 2: The latest version of Monatron, by Mauro Jaskelioff, together with our Monad Zipper are now available on Hackage. Note that the organization of Monatron is somewhat revised compared to the version used in our paper, but the Monad Zipper approach is exactly the same.

IFL 2010: Call for Papers

2010-03-20T11:07:00.002+01:00

CALL FOR PAPERS

22nd Symposium on Implementation and Applications of Functional Languages (IFL 2010)
September 1-3, 2010
Utrecht University
Alphen aan den Rijn, The Netherlands
http://www.cs.uu.nl/wiki/bin/view/IFL2010/WebHome


After a first successful visit to the USA, the Symposium on Implementation and Applications of Functional
Languages returns to Europe for its 22nd edition. The hosting institution is Utrecht University in the
Netherlands, although the conference itself will take place in the ornithological theme park Avifauna
in Alphen aan den Rijn, situated conveniently close to Schiphol (Amsterdam Airport). The symposium dates
are September 1-3, 2010.

The goal of the IFL symposia is to bring together researchers actively engaged in the implementation and
application of functional and function-based programming languages. IFL 2010 will be a venue for researchers
to present and discuss new ideas and concepts, work in progress, and publication-ripe results related to
the implementation and application of functional languages and function-based programming.

Following the IFL tradition, IFL 2010 will use a post-symposium review process to produce formal proceedings
which will be published by Springer Verlag in the Lecture Notes in Computer Science series. All participants in
IFL 2010 are invited to submit either a draft paper or an extended abstract describing work to be presented
at the symposium. At no time may work submitted to IFL be simultaneously submitted to other venues. Here
we follow the ACM Sigplan republication policy as defined on http://www.sigplan.org/republicationpolicy.htm.
The submissions will be screened by the program committee chair to make sure they are within the scope of IFL,
and will appear in the draft proceedings distributed at the symposium. Submissions appearing in the draft
proceedings are not peer-reviewed publications. After the symposium, authors will be given the opportunity
to incorporate the feedback from discussions at the symposium and will be invited to submit a revised full
article for the formal review process. These revised submissions will be reviewed by the program committee
using prevailing academic standards to select the best articles, which will appear in the formal proceedings.

INVITED SPEAKER

Johan Nordlander of Lulea University, the designer and developer of the Timber language, is the invited
speaker at IFL 2010. Timber is a functional programming language that draws some of its concepts from
object-oriented programming, and has built-in facilities for concurrent execution. The language is
specifically targeted at implementing real-time embedded systems.

TOPICS

IFL welcomes submissions describing practical and theoretical work as well as submissions describing
applications and tools. If you are not sure that your work is appropriate for IFL 2010, please contact
the PC chair at jur@cs.uu.nl. Topics of interest include, but are not limited to:

language concepts
type checking
contracts
compilation techniques
staged compilation
runtime function specialization
runtime code generation
partial evaluation
(abstract) interpretation
generic programming techniques
automatic program generation
array processing
concurrent/parallel programming
concurrent/parallel program execution
functional programming and embedded systems
functional programming and web applications
functional programming and security
novel memory management techniques
runtime profiling and performance measurements
debugging and tracing
virtual/abstract machine architectures
validation and verification of functional programs
tools and programming techniques
industrial applications of functional programming

PAPER SUBMISSIONS

Prospective authors are encouraged to submit papers or extended abstracts to be published in the draft proceedings
and to present them at the symposium. All contributions must be written in English, conform to the Springer-Verlag
LNCS series format and not exceed 16 pages. The draft proceedings will appear as a technical report of the
Department of Computer Science of Utrecht University.

PETER LANDIN PRIZE

The Peter Landin Prize is awarded to the best paper presented at the symposium every year.
The honored article is selected by the program committee based on the submissions received for
the formal review process. The prize carries a cash award equivalent to 150 Euros.

IMPORTANT DATES

Draft proceedings submission deadline   July 25, 2010
Registration deadline                   August 1, 2010
IFL 2010 Symposium                      September 1-3, 2010
Submission for review process deadline  October 25, 2010
Notification Accept/Reject              December 22, 2010
Camera ready version                    February 17, 2011


PROGRAM COMMITTEE

Jost Berthold    University of Copenhagen (DIKU), Denmark
Olaf Chitil   University of Kent, UK
John Clements   California Polytechnic State University, USA
Matthew Fluet   Rochester Institute of Technology, USA
Andy Gill   Kansas University, USA
Jurriaan Hage (Chair) University of Utrecht, Netherlands
Bastiaan Heeren  Open University, Netherlands
Ralf Hinze   University of Oxford, UK
John Hughes   Chalmers University of Technology, Sweden
Yukiyoshi Kameyama  University of Tsukuba, Japan
Gabriele Keller  University of New South Wales, Australia
Pieter Koopman   Radboud University Nijmegen, Netherlands
Luc Maranget   INRIA, France
Simon Marlow   Microsoft Research, UK
Marco T. Morazan  Seton Hall University, USA
Rex Page   University of Oklahoma, USA
Ricardo Pena   Universidad Complutense de Madrid, Spain
Sven-Bodo Scholz  University of Hertfordshire, UK
Tom Schrijvers   Catholic University of Leuven, Belgium
Don Stewart   Galois, USA
Wouter Swierstra  Vector Fabrics, Netherlands
Don Syme   Microsoft, UK
Peter Thiemann   University of Freiburg, Germany
Phil Trinder   Heriott-Watt University, Scotland
Janis Voigtlaender  University of Bonn, Germany
Viktoria Zsok   Eotvos Lorand University, Hungary

PhD Position for Datalog Research

2010-02-01T22:30:00.001+01:00

Declarative Languages and Artificial Intelligence Group
Department of Computer Science
Catholic University of Leuven, Belgium

The Declarative Languages and Artificial Intelligence Group at the Catholic
University of Leuven is looking for doctoral research candidates in the area of
Datalog.
The position concerns research related to language development, program
optimization, integration with constraint solvers, problem modeling,
refactoring, profiling, debugging, ... Close collaboration with our US-based
industrial partner is expected.

Applicants should have a masters degree in Computer Science or equivalent.
Experience in at least one of Datalog, logic programming (Prolog, ASP, ...),
databases or constraint programming is required. Implementation experience is
an important asset.

Appointment to the doctoral position will be for the period of one year
initially with possibility for extension to four years ending in a Ph.D. The
salary is compatible with the departmental rates for doctoral research fellows.

Please direct inquiries and applications, preferably by e-mail, to:

Professor Bart Demoen
Department of Computer Science
K.U.Leuven
Celestijnenlaan 200A
B-3001 Heverlee
Belgium

Email: bart.demoen@cs.kuleuven.be
Phone: +32 16 327547

Notice of interest (including motivation and CV) should be received as soon as
possible. Review of applications begins as of March 1, 2010, and the start date
is determined in consultation with the selected candidate.

CULP 2010: Commercial Users of Logic Programming workshop

2009-12-15T18:13:00.003+01:00

This year's workshop for Commercial Users of Logic Programming (CULP 2010) takes place on July 21, 2010 in Edinburgh (UK) at the occasion of the International Conference Logic Programming and the Federated Logic Conference (8 conferences related to logic in computer science).

If you're a commercial user of Logic Programming technology or theory, do consider giving a talk at CULP 2010 and share your experience. If you're a Logic Programming researcher, please tell all your industrial partners about CULP 2010 and encourage them to participate.

More information on the CULP 2010 website.

New Release of Prolog Type Checker

2009-12-11T15:05:00.004+01:00

Here is a new release of the Prolog type checker:

Based on extensive use by a.o. Jose Santos the compatibility with Yap has been considerably improved, and many features have been added. See the documentation at the start of type_check.pl.

Postdoc/PhD Positions on the Monadic Constraint Programming project

2009-11-04T16:48:00.003+01:00

The position has been filled.

Haskell Type Constraints Unleashed

2009-11-04T11:25:00.004+01:00

Update: Due to the canceled flights, Dominic has not been able to present our paper at FLOPS.
However, he's made a nice video of his talk that the FLOPS organizers have made available on a discussion page for the paper.

Dominic Orchard and I have written a new paper on new type system features for supporting EDSLs.

Haskell Type Constraints Unleashed
D. Orchard, T. Schrijvers

The popular Glasgow Haskell Compiler extends the Haskell 98 type system with several powerful features, leading to an expressive language of type terms. In contrast, constraints over types have received much less attention, creating an imbalance in the expressivity of the type system.
In this paper, we rectify the imbalance, transferring familiar type-level constructs, synonyms and families, to the language of constraints, providing a symmetrical set of features at the type-level and constraint-level. We introduce constraint synonyms and constraint families, and illustrate their increased expressivity for improving the utility of polymorphic EDSLs in Haskell, amongst other examples. We provide a discussion of the semantics of the new features relative to existing type system features and similar proposals, including details of termination.

We greatly appreciate your feedback. Also example of other problems that could be solved by the new features are very welcome.

Release 0.6 of Monadic Constraint Programming

2009-10-07T15:59:00.003+02:00

We've just released version 0.6 of the Monadic Constraint Programming framework on Hackage.

This release provides a whole lot of generic support for Finite Domain (FD) constraint solvers: a common modeling language and infrastructure for targeting different backends. Very useful if you happen to develop an FD solver and want to hook it up to our framework to benefit from its advanced search capabilities.

Users will of course be much more interested in the actual backends that we provide. Besides the basic Haskell FD solver we had before, there are now three different ways of interfacing Gecode, one of the best FD solvers out there and open source too. To get started, the examples directory shows how to model a number of well-known problems.

Haskell @ AOSD 2010

2009-09-07T21:16:00.002+02:00

How to reason about effectful advice? Write your AOP programs in Haskell, the world's best imperative programming language. Use monads and monad transformers for effects and functional mixins for advice. In return you get powerful reasoning tools: equational reasoning and parametricity.

Update: Our paper on the topic has been accepted at AOSD 2010. The technical report has some pretty cool parametricity proofs in its appendix on non-interference of advice, based on Janis' Voigtlaender's ICFP'09 paper "Free Theorems Involving Type Constructor Classes". Slides of my PLSIG seminar at K.U.Leuven are also available.

EffectiveAdvice: Disciplined Advice with Explicit Effects
Bruno Oliveira, Tom Schrijvers and William Cook
Abstract

Advice is a mechanism, widely used in aspect-oriented languages, that allows one program component to augment or modify the behavior of other components. Advice is useful for modularizing concerns, including logging, error handling, and some optimizations, that would otherwise require code to be scattered throughout a system. When advice and other components are composed together they become tightly coupled, sharing both control and data flows. However this creates important problems: modular reasoning about a component becomes very difficult; and two tightly coupled components may interfere with the control and data flows of each other.

This paper presents EffectiveAdvice, a disciplined model of advice, inspired by Aldrich's Open Modules, that has full support for effects in both base components and advice. With EffectiveAdvice, equivalence of advice, as well as base components, can be checked by equational reasoning. The paper describes an implementation of EffectiveAdvice as a Haskell library and shows how to use it to solve well-known programming problems. Advice is modeled by mixin inheritance and effects are modeled by monads. Interference patterns previously identified in the literature are expressed as combinators. Parametricity, together with the combinators, is used to prove two harmless advice theorems. The result is an effective model of advice that supports effects in both advice and base components, and allows these effects to be separated with strong non-interference guarantees, or merged as needed.

Monadic Constraint Programming with Gecode

2009-08-04T16:00:00.003+02:00

We have a new paper available, reporting on the next stage in the Monadic Constraint Programming project:

Monadic Constraint Programming with Gecode
Pieter Wuille and Tom Schrijvers

This paper presents FD-MCP, a finite domain modeling language on top of the
Monadic Constraint Programming framework for Haskell. FD-MCP leverages
Haskell's rich static type system and powerful abstraction mechanisms for
implementing syntactic sugar, model transformations and compilation to
solver backends. Two backends are provided: a basic Haskell solver and a
Gecode code generator.
Our benchmarks establish that FD-MCP models are much more concise than
hand-coded Gecode programs, more so when using disjunction, without sacrificing
performance.

The code is available from the project page.

NEW: The paper has been accepted at ModRef 2009, and a revised version is available.

16th Prolog Programming Contest Results

2009-07-18T19:02:00.004+02:00

[Here are my photos of the contest.]

Most of you already know what the Prolog programming contest is about. To the
others I have to say, shame on you! The contest is of course about locking up
several teams of Prolog programmers in a room for two hours with 5 challenges.
Each team has at most 3 members and one laptop. The team that solves most
challenges in the least amount of time is the winner.

You should know that the first rule of the contest is:

The contest is for fun and there are no losers.

Of course, there are losers outside of the contest, with silly excuses for
not participating, like:
- I have to go sight-seeing in Hollywood tonight, or
- My talk for the Commercial Users workshop is not written yet.
The silliest of all is:
- I don't know Prolog.
How low can you go.

Fortunately, we had many eager and willing participants. Very few of them had
to be pressed into it. They readily agreed, even before their first coffee of
the morning! No less than 10 teams showed up.
So we had
- 2 all-American teams,
- 3 Leuven teams,
- 1 team from Italy and 1 from Spain,
- a bunch of Danish rookies, and
- 2 mixed teams
* an Austrian, Scottish, and commercial New-Zealander team
* a French-Dutch-Italian team with Marco Gavanelli.

In fact, Marco is the only of of last year's winners here to defend the
title. Shame on the other two.

Now, I must say it is at least as much fun running the contest as it is
participating. You get to watch all the teams in action, doing all kinds of
things to get ahead. Like swapping around the keyboard. The Italians were
really smart, reading the challenge pages on both sides simultaneously.

You learn a lot of things running the contest. For instance, reading the
problem statement is actually useful: minimizing the maximal distance is not
the same as computing the average. Another one: Did you know that Danes read
from left to right, but write from right to left. Finally, a revelation:
base cases do seem to be essential.

Before we move on to the ranking, there are a number of people I have to
thank. Firstly, there is Bart Demoen, the creator of this contest who has
helped me with the problem statements and given practical advice on running
the contest. He enjoys a well-deserved sabbatical from the contest this
year. Thank you, Bart!

Secondly, I would like to thank the local organizers, Hai-Feng Guo and Gopal
Gupta, who have provided us with an excellent venue and sponsoring the prizes.
Thanks to Brian DeVries, Stanley Jointer and their colleagues, who have helped
get everything ready and put the room back to order after the herd of Logic
Programmers. Thanks guys!

Also thanks to the program chairs, Pat and David, for making the Programming
Contest an integral part of the program. Thank you!

Last but not least, I would like to thank my wife, Annemie, who has
created the prizes. Thank you.

Now, on to the ranking. This year's challenges were too easy. All teams had
at least one solution, and most teams had more than one. We got 38
submissions, of which 25 were correct. Bart Demoen would be ashamed of
passing so many. With the challenges being so easy having 3 correct
solutions was not enough to make the top 3.

The team that came in third, with four submission and four correct answers, is
the team of Alessandro Dal Palu, Agostino Dovier and Enrico Pontelli!

Then, there are two teams left: the team of Leslie De Coninck and the team
of Jan Wielemaker. Both know they have four correct submissions, but Jan's
team has also submitted a solution for the 5th challenge. Sorry guys, but
Jan's team forgot a base case there, and the other team was more than 100
minutes ahead. So I'd like to call forward this year's winners:
Leslie De Koninck, Hanne Vlaeminck and Peter Van Weert!

I hope you enjoyed it.

Tom

Prolog Programming Contest

2009-07-16T04:14:00.002+02:00

The 16th Prolog Programming is in full swing with 10 teams competing for the title of best Prolog programmers of the year.

You can still participate in the online contest.

The 16th Prolog Programming Contest

2009-07-02T11:52:00.001+02:00

The 16th Prolog Programming contest takes place at 6pm on July 15 at
ICLP 2009 in Pasadena (CA), USA. There is also a web contest for those
who cannot make it to ICLP.

Have a look at the contest website for the details.

CULP 2009 programme

2009-06-12T13:31:00.003+02:00

The Commercial Users of Logic Programming (CULP 2009) takes place on July 16 in Pasadena, CA, during ICLP 2009. We have 8 great speakers -- you can see the programme below. Everyone is welcome to attend!

9.30 - 10.20: Session 1
- 9.30 - 9.55: Mike Elston, Scientific Software and Systems Ltd.
  From Prolog to Porsche: experiences developing a large scale financial application in Prolog.
- 9.55 - 10.20: Terrance Swift, CENTRIA.
  The logic of programming in Prolog: then and now.
10.20 - 10.50: Coffee break
10.50 - 12.40: Session 2
- 10.50 - 11.15: Molham Aref, LogicBlox.
  Logic for enterprise decision automation applications.
- 11.15 - 11.40: Lindsey Spratt, Ontology Works Inc.
  The Ontology Works deductive database system.
- 11.40 - 12:05: David Warren, XSB Inc.
  From data to knowledge.
- 12.05 - 12.40: Discussion
12.40 - 14.40: Lunch break
14.40 - 15.55: Session 3
- 14.40 - 15.05: Hai-Feng Guo, Logical Software Solutions.
  TransBraille: completely automatic backtranslation of braille
  mathematics documents.
- 15.05 - 15.30: Benjamin Grosof, Vulcan.
  Hyper logic programs in SILK for business and science: an overview.
- 15.30 - 15.55: Walter Wilson, SDA Inc.
  An automated targeting system for US customs and border patrol inspectors.

Chris Mungall has joined Planet Prolog

2009-05-21T10:26:00.001+02:00

Chris Mungall has joined Planet Prolog with his Blip Blog on Logic Programming in Biology.

Dictionaries: Eager or Lazy Type Class Witnesses?

2009-05-15T19:08:00.003+02:00

Today, I gave a talk at the Cambridge computer lab:

Type classes are Haskell’s acclaimed solution to ad-hoc overloading. This talk gives an introductory overview of type classes and their runtime witnesses, dictionaries. It asks the questions whether dictionaries should abide by Haskell’s default lazy evaluation strategy.

Conceptually, a type class is a type-level predicate: a type is an
instance of a type class iff it type provides an implementation for
overloaded functions. For instance, `Eq a’ declares that type `a’
implements a function `(==) :: a → a → Bool’ for checking equality.

Type classes are used as constraints on type variables, in so-called
constrained polymorphic functions. E.g. `sort :: Ord a => [a] → [a]’
sorts a list with any type of elements `a’ that are an instance of the
Ord type class, i.e. provide implementations for comparison.

Witnesses for type class constraints are necessary to select the appropriate implementation for the overloaded functions at runtime. For instance, if `sort’ is called with Int elements, the Int comparison must be used, versus say Float comparison for Float elements.

Two forms of witnesses have been considered in the literature, runtime type representations and so-called dictionaries, of which the latter are the most most commonly implementation, e.g. in GHC . Haskell implementations treat dictionaries just like all other data, as lazy values that may potentially consists of non-terminating computations. This way part of the type checker’s work, who has made sure that the dictionaries do exist, is simply forgotten. Is this really necessary? Can performance be gained by exploiting the strict nature of dictionaries?

You can get the slides here.

Attributed Data for CHR Indexing

2009-04-08T14:55:00.003+02:00

Our ICLP 2009 submission was accepted:

Attributed Data for CHR Indexing
Beata Sarna-Starosta and Tom Schrijvers

The overhead of matching CHR rules is alleviated by constraint store indexing. Attributed variables provide an efficient means of indexing on logical variables. Existing indexing strategies for ground terms, based on hash tables, incur considerable performance overhead, especially when frequently computing hash values for large terms.
In this paper we (1) propose attributed data, a new data representation for
ground terms inspired by attributed variables, that avoids the overhead
of hash-table indexing, (2) describe program analysis and transformation
techniques that make attributed data more effective, and (3) provide
experimental results that establish the usefulness of our approach.

Get the current version here, or come and attend the talk at ICLP in Pasadena.

New blogger on Planet Prolog: Jocelyn Paine

2009-03-03T12:48:00.002+01:00

Jocelyn Paine's blog is now available on Planet Prolog.

Complete and Decidable Type Inference for GADTs

2009-03-02T20:23:00.005+01:00

We have a new approach to type inference for GADTs that's much simpler than previous approaches and not ad-hoc:

Complete and Decidable Type Inference for GADTs
Tom Schrijvers, Simon Peyton Jones, Martin Sulzmann, Dimitrios Vytiniotis
Submitted to ICFP 2009

GADTs have proven to be an invaluable language extension, a.o. for ensuring
data invariants and program correctness. Unfortunately, they pose a tough
problem for type inference: we lose the principal-type property, which is
necessary for modular type inference.

We present a novel and simplified type inference approach for local type
assumptions from GADT pattern matches. Our approach is complete and decidable,
while more liberal than previous such approaches.

Get the draft.

Commercial Users of Logic Programming

2009-02-24T22:29:00.003+01:00

Are you a commercial user of Logic Programming (Prolog, CHR, CLP, ASP, ...)?

Consider giving a talk at CULP 2009!

COMMERCIAL USERS OF LOGIC PROGRAMMING
CULP 2009

http://www.cs.kuleuven.be/~toms/CULP2009/
Pasadena, CA, USA -- July 13-17
Co-located with ICLP 2009

CALL FOR COMPANIES

Academic research in Logic Programming goes back at least as far as the early
1970s -- that is already more than 35 years. During most of that time, ICLP has
been the premier venue for presenting academic research, and many more related
workshops and symposia exist. At the same time, Logic Programming is being
used widely in industry. However, it has enjoyed at lot less visibility there,
and until now it has lacked a designated forum that brings together industrial
practitioners and researchers.

The goal of this first Commercial Users of Logic Programming (CULP) workshop is
to put the commercial and practical use (and users) of Logic Programming in the
spotlight. It aims at providing professionals with an opportunity to share
their experience, and to enable contacts with other commercial users and
academics.

If you use Logic Programming in a commercial, industrial or governmental
setting, we warmheartedly invite you to consider giving a talk at the workshop.
Alternatively, if you know someone who would give a talk, please forward this
message to them.

FORMAT

CULP is organized as a workshop co-located with the 25th International
Conference on Logic Programming. The workshop takes place on a date to be
determined between July 13-17, 2009, in the Pasadena Convention Center in
Pasadena, California, USA.

Presentations will have 30 minute slots, of which at least 5 are reserved for
discussion. They inform participants about the use of logic programming in an
industrial setting.

Insights and reflections on many aspects are sought. For example, but not
exclusively:
- Programming in the different stages and styles of commercial development,
- Engineering, scalability and usability issues,
- Success stories and (non-)viability of Logic Programming in particular
application areas,
- Aspects not directly related to application development, such as marketing,
recruitment, management,...,
- ...

Novel research results are not expected. Of course, novel fields of application
and novel approaches will be very welcome.

SUBMISSIONS

If you are interested in presenting at CULP 2009, send an e-mail to
tom -dot- schrijvers -at- cs -dot -kuleuven -dot -be
with your name, affiliation and a short description (at most one page)
of the proposed talk.

Full paper submissions are not required.

IMPORTANT DATES

Submission before: April 5, 2009
Notification: April 15, 2009
CULP workshop: July 13-17, 2009

CONFIRMED PRESENTATIONS

The following companies have already confirmed to give a presentation.

- Logic Blox http://www.logicblox.com/
- Logisoft Solutions LLC http://www.logicalsoft.net/
- Scientific Software and Systems Ltd. http://www.sss.co.nz/
- US Department of Defense
- XSB Inc. http://www.xsb.com/

CLP(FD) in the ASP solver competition

2009-02-16T13:24:00.002+01:00

If you want to join the CLP(FD) team in the ASP solver competition,
read this tread in comp.lang.prolog.

Vlaamse Programmeerwedstrijd

2009-01-13T20:56:00.002+01:00

De eerste Vlaamse Programmeerwedstrijd (VPW 2009) gaat door op woensdag 4 maart 2009 vanaf 14u in het gebouw van het departement Computerwetenschappen van de KULeuven.

Leerlingen uit het secundair onderwijs en uit het hoger onderwijs (hogeschool en universiteit) kunnen deelnemen aan de VPW. De teams worden opgedeeld in 2 categorien: teams bestaande uit leerlingen van het secundair of eerste bachelor studenten en teams met studenten vanaf de tweede bachelor (met inbegrip van de masters). Programmeren kan in Java, C, C++, Ruby, Haskell en Prolog.

Binnen elke categorie krijgen de drie beste programmeerteams een prijs. In totaal is er 2000 euro prijzengeld dankzij onze sponsors.

Meer info hier.

ICLP 2009 doctoral consortium

2009-01-08T20:22:00.005+01:00

Are you a Ph.D. student in the are of Logic Programming, or considering to start one? Then the ICLP 2009 doctoral consortium is just the thing for you:

You get to attend the International Conference on Logic Programming.
You'll meet lots of famous people in your area of research.
You get a forum to present your own ideas, goals (and current results).
Part of your expenses will be covered (depending on funds). For instance, last year registration fee and accomodation were covered.
All this takes place in Pasadena, California.

The submission deadline is April 10, 2009. More information here.

Monadic Constraint Programming

2009-01-05T11:42:00.013+01:00

by Tom Schrijvers, Peter Stuckey and Philip Wadler

Edit: The slides of my invited talk at WLP 2009 on Monadic Constraint Programming are now available.

Abstract:

A constraint programming system combines two essential components: a constraint solver and a search engine. The constraint solver reasons about satisfiability of conjunctions of constraints, and the search engine controls the search for solutions by iteratively exploring a disjunctive search tree defined by the constraint program. In this paper we give a monadic definition of constraint programming where the solver is defined as a monad threaded through the monadic search tree. We are then able to define search and search strategies as first class objects that can themselves be built or extended by composable search transformers. Search transformers give a powerful and unifying approach to viewing search in constraint programming, and the resulting constraint programming system is first class and extremely flexible.

Let's briefly look at the n queens example from the paper. First, there is the nqueens model:


nqueens n = exist n $ \queens -> model queens n /\
                                 enumerate queens

model queens n = queens ‘allin‘ (1,n) /\ 
                 alldifferent queens /\ 
                 diagonals queens
 
allin queens range = conj [q ‘in_domain‘ range | q <- queens ]     alldifferent queens = conj [ qi @\= qj | qi:qjs <- tails queens,                                          qj <- qjs ]  diagonals queens = conj [ qi @\== (qj @+ d) /\ qj @\== (qi @+ d)                         | qi:qjs <- tails queens, (qj,d) <- zip qjs [1..]]  conj = foldl (/\) true

The enumeration of possible values can be quite sophisticated, e.g.


enumerate = Lazy . (label firstfail middleout)

where firstfail selects the queen with the smallest
domain first, and middleout selects the middle values
in the domain first. You can easily write custom variable and
value selection strategies, or alternative enumeration functions.

To actually compute solutions, we have to solve the model:


> solve dfs it $ nqueens 4
[[2,4,1,3],[3,1,4,2]]

i.e. we yields these two solutions of 4 queens:

The search strategy used above is depth-first search (dfs) without
any additional search transformers (i.e. identity transformer it).
Here are three variations, using alternative search strategies:


> solve dfs (nb 100 :- db 25 :- bb newBound) $ nqueens 4
> solve bfs (db 25 :- nb 100 :- bb newBound) $ nqueens 4
> solve bfs (ld 10 :- nb 100 :- bb newBound) $ nqueens 4

where

bfs is the breadth-first queueing strategy,

nb n stops search after visiting n nodes in the search tree,

dbn does not visit nodes below depth n in the search tree,

ld n does not visit nodes that are more than n right branches from the root of the search tree (limited discrepancy), and

bb newBound is branch-and-bound optimization (in this example the value of the last queen is minimized; makes more sense for other problems).

The :- operator combines the various (composable) search transformers. The purpose of these search transformers is of course to find (all, one, the best) solutions more quickly.

More

Draft paper
Prototype code (requires GHC >= 6.10)

Your feedback is appreciated.

Constraint Handing Rules: Current Research Topics

2009-01-01T12:32:00.002+01:00

About this book

The Constraint Handling Rules (CHR) language is a declarative concurrent committed-choice constraint logic programming language consisting of guarded rules that transform multisets of relations called constraints until no more change occurs.

The CHR language saw the light more than 15 years ago. Since then, it has become a major declarative specification and implementation language for constraint-based algorithms and applications. In recent years, five workshops on constraint handling rules have spurred the exchange of ideas within the CHR community, which has led to increased international collaboration, new theoretical results and optimized implementations.

The aim of this volume was to attract high-quality research papers on these recent advances in Constraint Handling Rules. The 7 papers presented together with an introductory paper on CHR cover topics on search, applications, theory, and implementation of CHR.

Uniting the Prolog Community @ ICLP 2008

2008-12-15T09:52:00.000+01:00

by Tom Schrijvers and Bart Demoen

In his article "A Wake-Up Call for the Logic Programming Community",
published in the ALP Newsletter, Tom raised several concerns about the
viability of the Prolog programming language in the near future.

This session on "Uniting the Prolog Community" was organized to reiterate these
concerns, to announce recent positive developments and to involve the whole
community in the discussion.
Bart started out with an overview of the issues at stake:
1. Love & Passion: for Logic Programming, and Prolog in particular
(witnessed by the packed sala Floria)
2. Separation: many fragmented systems
3. Guilt: for causing separation
4. Jealousy & Envy: for more thriving communities
5. Hope & Reconciliation: SWI-Prolog and Yap are joining forces
He ended with a call to the audience to contribute with positive arguments.

Next, Tom compared the state of affairs between the Prolog and Haskell communities. The Haskell community strongly integrates researchers, hobbyists, open source volunteers and industry. For Prolog the picture is much less clear.
Few attendants could name more than one company using Prolog. This does not indicate so much that they don't exist, but rather that the community as a whole is simply not aware of them. In order to address the separation issue, Tom suggested we might learn a thing or two from Haskell community tools, of which the two most important ones are a community-maintained wiki portal with all the information you may possibly want to know about the language, and a library database for code sharing.

Jan Wielemaker and Vitor Santos Costa reported on a hopeful development: they are joining forces, sharing code and increasing portability between their systems. All parties benefit, not only the users of YAP and SWI, but also Jan and Vitor who do not have to do the same work twice. Vitor concluded with a challenge for the community: we should give the outside world (and ourselves) a strong message: Prolog is simply the best and we can do things with it that others simply cannot conceive.

In the last presentation, Paulo Moura related on the pain and struggle to port a Prolog application to different system. If Prolog systems would behave more consistently, his life and that of many other users would be so much easier.

Throughout we had plenty of constructive discussion and suggestions from all the participants. For instance, Michael Codish reminded us of LP teachers and LP users in other communities, such as Natural Language Processing, and Markus Triska pointed out the existence of a #prolog IRC channel. Many other good points were raised.

Will all this discussion lead to any concrete action? The answer is yes! The developers of Ciao, SWI-Prolog and Yap will reconcile at a hackaton beginning next year, to improve interoperability bottom-up. The ALP is setting up a wiki on very short term, and programming competitions will be organized to improve Prolog's presence at the Programming Language Shoot-Out. The rest is up to you: content for the wiki, programs for the shoot-out, and libraries for the interoperable Prolog systems. Other ideas are welcome and the wiki will give you the means to realise them.

The session ended in an optimistic atmosphere and we are very grateful for the positivism of the participants.

Finally, we would like to thank the ALP, the program chairs and local organizers for giving us the opportunity to organize this session.

We hope to see you again next year, at ICLP 2009, with more good news.

?- can(we).
Yes

Type Invariants for Haskell

2008-11-14T15:55:00.000+01:00

Our paper on Type Invariants for Haskell was recently accepted at PLPV'09. It contains a proposal for extending the power of type families (and type classes) by allowing the programmer to express invariants about them.

Type Invariants for Haskell
Tom Schrijvers, Louis-Julien Guillemette, Stefan Monnier

Abstract
Haskell's multi-parameter type classes, together with functional dependencies, allow the specification of complex type-level operations, and the recent introduction of open type families in GHC makes such type-level programming even more accessible and flexible. But type-level code is special in that its correctness is crucial to the safety of the program; so except in those cases simple enough for the type checker to see trivially that the code is correct (or harmless), type-level programs need to come with their specification and correctness proof.
In this article, we propose an extension to Haskell that allows the specification of invariants for type classes and open type families, together with accompanying evidence that those invariants hold. To accommodate the open nature of type classes and type families, the evidence itself needs to be open and every subcase of the proof can be provided independently from the others.

Get the paper here.

Mockitator uses CHR

2008-09-13T15:41:00.000+02:00

Here's another bit of evidence of CHR's industrial relevance: a commercial product, for test generation, using CHR:

AgitarOne is a comprehensive unit testing product for Java developed at Agitar Software. It combines tools for software agitation (a technique for exploratory testing), regression test generation, reporting, and continuous integration. Test generation is supported in AgitarOne by two distinct test generation engines. Agitar’s Agitator is a dynamic test generation engine that uses runtime feedback and limited on-the-fly static analysis to generate input data for software agitation and for regression test generation. Agitar’s Mockitator (internal code-name) is a static test generation engine that creates regression tests based on static program analysis.

It mentions CHR right here that their software contains a modified version of JCHR, the Java implementation of CHR by Peter Van Weert.

Thanks to Peter Van Weert for spotting it.

Gradual Typing for Prolog

2008-09-02T01:29:00.000+02:00

(See my previous post titled "Types for Prolog")

I got the lead developers of two major open source Prolog systems, Vitor Santos Costa (Yap Prolog) and Jan Wielemaker (SWI-Prolog), interested in my Typed Prolog project. With their help and Bart Demoen's, the type checker library has much improved.

We've written up a summary of our work in a 5 page short paper (poster), which has just been accepted at ICLP:

Moving SWI and Yap gradually to Typed Prolog, T. Schrijvers, V. Santos Costa, J. Wielemaker, B. Demoen.

Come to the poster session in December to hear about it, or have a look at the draft right now.

Most notable new features of the new version:

new ways of interfacing typed and untyped code
the same function symbol in multiple types
new built-in types string and any

Also a number of error messages have been improved, and the type checker prints statistics after checking a file (number of clauses checked and errors found).

Get the latest version here: type_check.pl and functor_constraint.pl.

Stay tuned as more details will follow.

Type Checking with Open Type Functions

2008-04-03T09:43:00.000+02:00

We've got a new paper on the type checking algorithm for type functions/families:

Type Checking with Open Type Functions
T. Schrijvers, S. Peyton Jones, M. Chakravarty, M. Sulzmann

We report on an extension of Haskell with open type-level functions and equality constraints that unifies earlier work on GADTs, functional dependencies, and associated types. The contribution of the paper is that we identify and characterise the key technical challenge of entailment checking; and we give a novel, decidable, sound, and complete algorithm to solve it, together with some practically-important variants. Our system is implemented in GHC, and is already in active use.

New CHR Survey

2008-03-27T21:34:00.000+01:00

There's a new survey on CHR available here.

As Time Goes By: Constraint Handling Rules - A Survey of CHR Research from 1998 to 2007.
J. Sneyers, P. Van Weert, T. Schrijvers, L. De Koninck.

Constraint Handling Rules (CHR) is a high-level programming language based on multi-headed multiset rewrite rules. Originally designed for writing user-deﬁned constraint solvers, it is now recognized as an elegant general purpose language.
CHR-related research has surged during the decade following the previous survey by Fruwhwirth (1998). Covering more than 180 publications, this new survey provides an overview of recent results in a wide range of research areas, from semantics and analysis to systems, extensions and applications.

If there are any omissions or mistakes, please let me know!

Types for Prolog

2008-02-26T13:59:00.000+01:00

There's been quite a discussion on types over at comp.lang.Prolog. In my opinion types are essential for programming in the large. The lack of types is one of the reasons for making Prolog a small language.

So Prolog should have types that are statically enforced. What types? I'd rather not invent an awkwardly ad-hoc type system that fits existing code patterns. In order to make types work a lot for you, you must work a little too. What I mean is that certain programming style must be adopted that is not necessarily the anything-you-write-is-fine style of an untyped language. So why invent a new type system if we can reuse a tried-and-true one: the Hindley-Milner type system. It's been around for about 30 years, and applied with success in several languages. In particular, it's being used in Mercury, and it works!

Of course, we don't want to switch from Prolog to Mercury overnight. There's all the legacy code we don't have the time and money to port. Moreover, Mercury's demand for declarations is pretty heavy weight: not only types are demanded, but also modes and determinism.

That's why I started a type checker library in (SWI-)Prolog: type_check.pl. Include this library in your code, and you can use Mercury-style type declarations and predicate signatures.

Basic use the library

In order to use the type checker, you must include the library in your module:

:- use_module(type_check).

This way the type checker will be run whenever you load your library. Any type errors it finds, will be reported during the loading process.

Now, before you can use any types, you must defined them. This is done using Mercury-style type definitions. There are two forms. The first form is for defining a new algebraic data type. E.g.

:- type list(T) ---> [] ; [T|list(T)].

defines a polymorphic type of lists. Note that this particular type is already predefined by the type_check library, as well as a few others (integer/0, boolean/0 and pair/2, for now).

The second form is for defining an alias (type alias) of another type. E.g.

:- type intlist == list(integer).

defines a shorter name intlist for the type list(integer). For the type checker these two are equal.

Once you have defined the types you need, you can use them to write signatures for your predicates. E.g.

:- pred mem(E,list(E)).

states that mem/2's first argument is of any one type E and mem/2's argument is of type list(E). With the signature in place, you can happily write the predicate definition:

mem(X,[X|_]).
mem(X,[_|T]) :- mem(X,T).

Now load your module, and the type checker verifies wether the predicate definition conforms to the predicate signature. If it doesn't, it complains with an error message. There is no further runtime overhead (like runtime assertions): well-typed code can't go wrong.

Assume that I wrote the first clause as (the arguments switched):

mem([X|_],X).

When I load the file, I get the error message:

TYPE ERROR: expected type `list(list(_G759))' for term `_G730'
           inferred type `_G759'
       in head `mem([_G730|_G733], _G730)' of clause:
mem([A|_], A).

Admittedly, the error messages are currently far from the most informative, but this project has just begun. Your suggestions for improvement and patches are much appreciated.

Untyped legacy code

Of course, we still have that untyped legacy code. We don't want to type all that code, let alone rewrite it to make it typable. That's why I added the ability to have typed and untyped code interact in a safe manner:

When untyped code calls the typed code, a runtime test is performed right before the call to check whether the call is well-typed. This also holds for calls from the Prolog toplevel!
When typed code calls untyped code, you must annotate the call with a singature. A runtime check will then verify whether the call behaves according to its signature.

This was inspired by Phil Waddler's recent paper, which establishes that well-typed code is not to blame. Any type errors will be caught at the interface between the untyped and the typed code, and the untyped code is to blame.

You can find a fully annotated library module for binomial heaps here. It's a port from Haskell code.

Union-Find has Linear Time Complexity

2008-02-02T13:39:00.001+01:00

There is a new time complexity result for the union-find algorithm by Hantao Zhang. Tarjan showed that the algorithm has near linear complexity: O( n . a(n)) where a(n) is the inverse Ackermann function. The new result shows that the algorithm in fact has a linear time complexity O(n).

This means that I have to revise the joint paper with Thom Fruehwirth on implementing union-find in CHR with optimal complexity. It's still optimal, but the absolute complexity is simply better :-)

CHR 2008 Announced

2008-01-30T10:53:00.000+01:00

The CHR 2008 workshop has just been announced. It will be held on July 14 in Hagenberg, Austria at the occasion of RTA 2008. I'm already looking forward to it!

New aggregates library in SWI-Prolog

2008-01-25T21:28:00.000+01:00

I just saw that a new library for aggregates was added in SWI-Prolog's GIT repository.
That should be pretty useful. It's not that difficult to write your own aggregation functions using findall and friends, but rather tedious. I bet there are plenty such handwritten aggregates in the CHR compiler. Let's see how many can be replaced with calls to this new library.

There is an interesting note in the library:

@tbd Analysing the aggregation template and compiling a predicate
for the list aggregation can be done at compile time.

It would be really cool to see Prolog systems do smart source code optimizations. All the manuals tell you how to exploit first-argument indexing and put your predicate arguments in the appropriate order. In my opinion it should really be the Prolog compiler that figures out what argument to index on, so that you as a programmer can choose argument order based on other factors. Yes, performance has to be predictable, but I bet nobody complains when the code runs faster than expected. There must be plenty of ways to do better than doing nothing.

Anyway, if you want to use it, you can grab it from the repository or wait for the next release, which should be soon.

Planet Prolog

2008-01-16T12:24:00.000+01:00

I learned about blog planets, and how easy they are to set up. There are many planets for other programming languages. One I enjoy reading is Planet Haskell.
Wouldn't it be neat to have a planet for Prolog. So I just went ahead and started Planet Prolog.

If you have a Prolog or Logic Programming related blog. Please let me know, and I'll gladly add you to Planet Prolog. Also tell your friends who may be interested.
This should be a great way to let other people know what's going on in the community!

TCHR: a framework for tabled CHR

2007-12-27T11:35:00.000+01:00

This joint paper with Bart Demoen and David S. Warren has just been accepted at the Theory and Practice of Logic Programming journal. It is the extended version of our award-winning ICLP 2004 paper.

Tabled Constraint Logic Programming is a powerful execution mechanism for dealing with Constraint Logic Programming without worrying about fixpoint computation. Various applications, e.g in the fields of program analysis and model checking, have been proposed. Unfortunately, a high-level system for developing new applications is lacking, and programmers are forced to resort to complicated ad hoc solutions.
This papers presents TCHR, a high-level framework for tabled Constraint Logic Programming. It integrates in a light-weight manner Constraint Handling Rules (CHR), a high-level language for constraint solvers, with tabled Logic Programming. The framework is easily instantiated with new application-specific constraint domains. Various high-level operations can be instantiated to control performance. In particular, we propose a novel, generalized technique for compacting answer sets.

A Wake-Up Call for the Logic Programming Community

2007-12-27T11:22:00.000+01:00

I have written an article for the ALP newsletter, comparing the Logic Programming community to the Functional Programming community and in particular the Haskell community.

In the 6 six years that I have been doing research in the Logic Programming community, I have met a lot of nice people and heard about a lot of interesting research ideas. However, the community itself isn't exactly thriving and LP has a serious PR problem. It's my fear that if we happily continue along our current path, then there will be little left of LP and its flagship Prolog in a couple of years...

Read the whole article.

Reactions:

Jim Law's blog article: "There is a massive body of experience in logic programming, Prolog in particular, that we can't afford to lose."
Anarchaia: "I hope it works."
Bernd Brassel:
"I have just read your wake up call for the logic programming community. It was very gripping and exactly what I felt. There is even one more point I would like to add to your pile of suggestions: improve the reviews for ICLP. Do you remember Norman Ramsey's speech about how thorough and thoughtful
reviews improve people's will to submit next time again, even if you were rejected? I think that was totally to the point. If you compare my reviews from ICLP with those of ICFP you can easily tell who took the work more seriously. And if for some reason I could only submit to one of those conferences this year, my choice would be clear..."
Michael Hanus:
"I just read your "Wake-Up Call" article. Congratulations
and many thanks for this article!

I fully agree with you since this largely overlaps with
my statement I presented at the ICLP 2005 panel discussion.
I concluded there with the suggestions:

Language design is not enough

- good web pages (e.g., activate www.logic-programming.org)
- collect resources, libraries, projects etc.
- show that LP is alive

ALP EC as a driving force (establish committee...)

This was also influenced from my experience with the
FP community. Unfortunately, I haven't seen much activity
since then, although this issue is crucial for the future of LP.

I hope that your wake-up call will have a better effect!"

Paulo Moura pointed me to his ALP newsletter article on Prolog standardization a while ago. From the article:
This would be a followup to my first newsletter article, published on May 1999. However, the present text turned out to be more political than technical. For a good reason. Six years later, what has changed? Not much, I'm afraid. Sure, several Prolog compilers, specially open-source ones, improved their compatibility with the Part I of the ISO Prolog standard. However, there is still no certification process in place or widely accepted conformance tests that a programmer may use and rely on when porting its Prolog applications...
Clive Spenser:
I do tend to agree with your analysis. Many years ago I tried to expose the commercial ues of Prolog thru the Prolog Vendors Group and Practical Applications of Prolog series of conferences
and seminars. Both the ALP and CompulogNet [at the time] where very supportive.
However, we have never been more than an interetsing niche language and suffered as the AI and Expert Systems wave has too gone up and down. Prolog is not an acceptable programming language within industry and seen a both our-dated by the new breed of programmers and not mainstream enough by the old breed.
Where does that leave us? Answers on a postcard please ....
regards,
Clive
FWIW: LPA do try to get customers to go public with their applications [like PDC, Sics etc]; you can read about some successful applications of LPA
Prolog on the LPA web-site.

Nested Parallel List Comprehensions

2007-11-21T14:15:00.001+01:00

It's been a couple of years ago that I read about parallel list comprehensions. I cannot remember actually seeing them used by anyone. Today I needed them, infact I needed them twice: nested parallel list comphrehension.

The problem is the n-queens puzzle. The object is to place n queens on an n-by-n chess board, such that the queens do not attack each other, i.e.

there are no two queens in the same column
there are no two queens in the same row
there are no two queens on the same diagonal

In Constraint Logic Programming the usual trick is to have a list of queens, where the position
in the list corresponds to the column of that queen. In this form the columns constraint is already satisfied.

Now only the column of the queen has to be determined. Hence, the representation of a queen is an integer constraint variable, denoting the row of that queen. We can easily satisfy the row constraint with an out-of-the-box CLP constraint, alldifferent, which forces a list of constraint variables to take on different variables.

Now, we are left with the diagonals constraints and not so many more trick left in our bag.
We have to set up n*(n - 1)/2 pairwise constraints between the queens, saying that they are not on the same diagonal. If the rows of two queens are q1 and q2 and their relative distance is n > 0 (hence q1 comes first), the diagonal constraint amounts to q1 \= q2 + n /\ q2 \= q1 + n (verify!). The tricky bit is to set up all the constraints from the list of queens.

Here's my solution:


queens qs = conj . map conj $
                 [  [ neqp q1 q2 n /\ neqp q2 q1 n
                    | n  <- [1..]
                    | q2 <- q2s
                    ]
                 | q1  <- qs
                 | q2s <- tails qs
                 ]

That's a nicely double nested use of parallel list comprehensions.

Did you ever use parallel list comprehension?

SingHaskell

2007-11-21T08:42:00.000+01:00

I'm currently visiting Martin Sulzmann in Singapore. We thought it'd be fun to organize a SingHaskell meeting next Wednesday, because there is a higher than usual concentration of Haskellers in Singapore then (it's right before APLAS, the Asian programming languages conferences). Want to come and/or present too? Let me know!

Type Functions for CPS Transformation

2007-11-21T03:46:00.000+01:00

Louis-Julien Guillemette presented A Type-Preserving Closure Conversion in Haskell at the Haskell Workshop. The type preservation involved a lot of manual proof term construction, using GADTs, i.e. at the value level.

I suggested converting his code to use type functions, our latest extension of the GHC type system, instead. This would lift the proof term construction from the value level to the type-level. More importantly, rather than having to construct the proof terms yourself, now the type checker does it automatically for you. It should yield savings in both brain power and lines of code.

He's taken up the challenge and sent me the adapted version of his code. Before, there were
397 LoC in his CPS transformer. Now there are only 264 LoC or 66.5%. That's a third less code! The ratio closure conversion versus type preservation is now much bigger: the eliminated code is related to type preservation only.

Update
Louis-Juilen has made his new TFP'08 paper "One Vote for Type Families in Haskell!" available. The paper has some interesting arguments for type families. The code itself is also available. The type families version is 30 times faster than the GADT version!

An extension proposal for Uniplate

2007-11-16T12:00:00.001+01:00

I'm working on a Haskell model for a Constraint Logic Programming search tree:


data Tree (sm :: * -> *) c t
= Fail
| Return
| Try (Tree sm c t) (Tree sm c t)
| Add c (Tree sm c t)         
| NewVar (t -> Tree sm c t)
| Label (sm (Tree sm c t))

for which I wrote this extension function:


extendTree :: Monad sm => Tree sm c t -> Tree sm c t -> Tree sm c t
Fail       `extendTree` k  = Fail
Return     `extendTree` k  = k
(Try m n)  `extendTree` k  = Try (m `extendTree` k) (n `extendTree` k)
(Add c m)  `extendTree` k  = Add c (m `extendTree` k)
(NewVar f) `extendTree` k  = NewVar (\x -> f x `extendTree` k)
(Label m)  `extendTree` k  = Label (m >>= \t -> return (t `extendTree` k))

which takes two trees and basically replaces all Return nodes in the first tree with the second tree.

Having attended Neil Mitchell's compelling talk at the Haskell Workhop, I wanted to try and see whether I could come up with a concise version with Uniplate.


instance Uniplate (Tree sm c t) where
uniplate = ...

j `extendTree` k = transform tf j
               where tf Return = k
                     tf x      = x

It turned out that I could not make (Tree sm c t) an instance of the Uniplate type class because of the NewVar and Label constructors. These two constructors do not allow their children to be inspected, because they are respectively hidden in a function and a monad.

To solve this problem, I propose to introduce a more limited type class, Semiplate, which only allows the transformation of its instances.


class Semiplate on where
  -- apply the given function to the children
  -- to construct a new value
  semiplate :: (on -> on) -> on -> on

instance Monad sm => Semiplate (Tree sm c t) where
  semiplate tf Fail  =  Fail
  ...
  semiplate tf (Newvar f)  = NewVar (\var -> tf (f var))
  semiplate tf (Label m)   = Label (m >>= \t -> return (tf f))

stransform :: Semiplate a => (a -> a) -> a -> a
stransform tf  = tf . (stransform tf)

Using GHC's overlapping instances, we can even make every Uniplate instance a Semiplate instance:


instance Uniplate on => Semiplate on where
  semiplate tf x  = construct (map tf children)
                  where (children,construct) = uniplate x

I have no idea whether this would be useful for other cases where Uniplate does not work out of the box.

First post

2007-11-16T05:48:00.001+01:00

This is my first post.