gmane.comp.lang.haskell.general

ICFP09 Announcement

Matthew Fluet (ICFP Publicity Chair — 2008-09-02T14:06:42

+--------------------------------------------------------------------+ ANNOUNCEMENT The 14th ACM SIGPLAN International Conference on Functional Programming ICFP 2009 31st August - 2nd September 2009 Edinburgh, United Kingdom ICFP provides a forum for researchers and developers to hear about the latest work on the design, implementations, principles, and uses of functional programming. ICFP 2009 will be held in Scotland's historic capital city of Edinburgh, during the final week of the Edinburgh International Festival. Further information is available from: http://www.cs.nott.ac.uk/~gmh/icfp09.html Graham Hutton General Chair, ICFP 2009 +--------------------------------------------------------------------+ | Dr Graham Hutton Email : gmh< at >cs.nott.ac.uk | | Functional Programming Lab | | School of Computer Science Web : www.cs.nott.ac.uk/~gmh | | University of Nottingham | | Jubilee Campus, Wollaton Road Phone : +44 (0)115 951 4220 | | Nottingham NG8 1BB, UK | +--------------------------------------------------------------------+

WLPE'08 - Call for Papers

WLPE-08 — 2008-09-02T11:02:09

WLPE'08 -- Call for Papers The 18th Workshop on Logic-based methods in Programming Environments http://www.clip.dia.fi.upm.es/Conferences/WLPE08/ December 9th-13th 2008, Udine, Italy (Satellite Workshop of ICLP 2008) The 18th Workshop on Logic-based methods in Programming Environments will take place in Udine (Italy), as a satellite workshop of ICLP 2008, the 24th International Conference on Logic Programming. This workshop will continue the series of successful international workshops on logic programming environments 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 (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) and Porto, Portugal (2007). More information about the series of WLPE workshops can be found at http://www.cs.usask.ca/projects/envlop/WLPE/ The workshop aims at providing an informal meeting for researchers working on logic-based methods and tools which support program development and analysis. This year, we plan to continue and consolidate the shift in focus from environmental tools for logic programming to logic-based environmental tools for programming in general, so that this workshop can be possibly interesting for a wider scientific community. In addition to papers describing more conceptual and theoretical work, the call for papers will solicit papers describing the implementation of, and the experience with, such tools. 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 and non-termination analysis - reasoning on occurs-check freeness and determinacy - profiling and performance analysis - type- and mode analysis - module systems - optimization tools Authors who are interested in taking part in the workshop, but are unsure if their work falls within its scope, are invited to contact the organizers and will be given suitable advice. Workshop Organizers ------------------- Puri Arenas Facultad de Informatica Universidad Complutense de Madrid 28040-Madrid, Spain Email: puri< at >sip.ucm.es Phone: +34 91 394 76 33 Fax: +34 91 336 50 18 http://www.clip.dia.fi.upm.es/puri Damiano Zanardini Facultad de Informatica Universidad PolitÃÂ©cnica de Madrid 28660-Boadilla del Monte, Madrid, Spain Email: damiano< at >clip.dia.fi.upm.es Phone: +34 91 336 74 48 Fax: +34 91 394 75 29 http://www.clip.dia.fi.upm.es/damiano Program Committee ----------------- - Puri Arenas, Universidad Complutense de Madrid (ws co-chair) - Michael Codish, Ben-Gurion University of the Negev - Roberta Gori, Universita di Pisa - Arnaud Gotlieb, IRISA/CNRS UMR 6074 - Patricia Hill, University of Leeds - Jacob Howe, City University, London - Sabina Rossi, Universita Ca' Foscari di Venezia - Tom Schrijvers, K.U.Leuven - Alexander Serebrenik, Technische Universiteit Eindhoven - Wim Vanhoof, University of Namur - German Vidal, Universidad Politecnica de Valencia - Damiano Zanardini, Universidad Politecnica de Madrid,(ws co-chair) Important Dates --------------- Submission: September 15th, 2008 (23:59:59 Samoa time (GMT -11)) Notification: October 8th, 2008 Camera-ready: October 26th, 2008 Workshop: December 12nd, to be confirmed Submission ---------- Papers should be submitted to http://www.easychair.org/conferences/?conf=wlpe2008 The length of papers can range from 2 to 15 pages in LNCS style. Informal proceedings will be distributed at the workshop. After the workshop, proceedings will be available on-line in the Computing Research Repository (CoRR). In addition to papers describing conceptual and theoretical work, papers describing the implementation of and the experience with tools are welcome._______________________________________________ Haskell mailing list Haskell< at >haskell.org http://www.haskell.org/mailman/listinfo/haskell

BYTECODE09: 1st Call for Papers

Samir Genaim — 2008-09-02T08:19:36

******************************************************** * 1st Call for Papers * * * * Fourth Workshop on Bytecode Semantics, * * Verification, Analysis and Transformation * * * * York, UK, 29th March 2009, part of ETAPS 2009 * * * * Venue: The University of York * * * * http://www.clip.dia.fi.upm.es/Conferences/BYTECODE09 * * * ******************************************************** Important Dates =============== Paper Submission December 21, 2008 Notification January 25, 2009 Final Version February 8, 2009 Workshop March 29, 2009 Workshop Description ==================== Bytecode, such as produced by e.g. .Net and Java compilers, has become an important topic of interest, both for industry and academia. The industrial interest stems from the fact that bytecode is typically used for the Internet and mobile devices (smartcards, phones, etc.), where security is a major issue. Moreover, bytecode is device-independent and allows dynamic loading of classes, which provides an extra challenge for the application of formal methods. In addition, the lack of structure of the code and the pervasive presence of the operand stack also provide extra challenges for the analysis of bytecode. This workshop will focus on the latest developments in the semantics, verification, analysis, and transformation of bytecode. Both new theoretical results and tool demonstrations are welcome. Invited Speaker =============== TBA Submission ========== There are two paper categories, Regular and Tool demo papers. Paper should be written using the ENTCS style and submitted through the easy chair page "http://www.easychair.org/conferences/?conf=bytecode08". Please indicate in the submission page the category of your submission. Submissions will be evaluated by the Program Committee for inclusion in the ENTCS proceedings. Regular research papers should be at most 15 pages (including bibliography and excluding well-marked appendices not intended for publication). They must contain original contributions, be written in English and be unpublished and not submitted simultaneously for publication elsewhere. Tool demo papers must describe a completed, robust and well-documented tool -- highlighting the overall functionality of the tool, the interfaces of the tool, interesting examples and applications of the tool, an assessment of the tool's strengths and weaknesses, and a summary of documentation/support available with the tool. The body of the paper must be no longer than 6 pages in length (including bibliography), and it should give an overview of the tool, the methodology associated with its use, a summary of how the tool has been applied and to what effect, and it should indicate what supporting artifacts (user manual, example repository, downloads, etc) are available. This material will be included in the ENTCS proceedings if the paper is accepted. In addition, the paper should include an appendix (limited to six pages) that gives an outline of the proposed demo presentation (this material will NOT appear in the ENTCS proceedings). Program Committee ================= Wolfgang Ahrendt Chalmers University of Technology, SWE Elvira Albert (co-chair) Complutense University of Madrid, ESP June Andronick Security Lab - Gemalto, FRA David Aspinall University of Edinburgh, UK Cristina Cifuentes Sun Microsystems, AUS Samir Genaim (co-chair) Technical University of Madrid, ESP Sara Kalvala The University of Warwick, UK Gerwin Klein The University of New South Wales, AUS Francesco Logozzo Microsoft Research, USA David Pichardie INRIA Rennes (IRISA), FRA Tamara Rezk INRIA-Microsoft, FRA Fausto Spoto University of Verona, ITA Eran Yahav IBM T.J. Watson Research Center, USA

The final view on typed sprintf and sscanf

2008-09-02T07:57:18

It would be remiss not to mention the dual solution to the problem of typed sprintf and sscanf sharing the same formatting specification. The previous message defined the embedded domain-specific language of formatting specifications in the initial style, as a data type. The language can also be defined in the final style. To the end user, the difference is hardly noticeable: all the tests of the previous message work as they are (modulo a few adjustments caused by the monomorphism restriction). However, whereas the initial style required GADT, the final solution is entirely in Haskell98. One often hears that hardly anything interesting can be written in Haskell98. I submit that implementing type-indexed terms, thought to require GADTs or similar dependent-type-like extensions, ought to count as interesting. Again, the formulation of the problem and the end-user interface remain exactly the same as described in the previous message. Here are a few examples: The only difference is the dummy unit argument to the fmt3 term, to keep it polymorphic and away from the monomorphism restrictions. Otherwise, the examples look the same and work the same. The complete code is available at http://okmij.org/ftp/Haskell/PrintScanF.hs It is Haskell98 and should work on any Haskell98 system (tested on GHC 6.8.2 and Hugs September 2006). Whereas the initial version defined the formatting language with the help of GADT, the final version uses a simple, single-parameter type class The printer and the scanner are two interpreters of the language The transformation from the initial to the final style follows the correspondence described in http://okmij.org/ftp/Computation/tagless-typed.html#in-fin In fact, PrintScanF.hs was `derived' from PrintScan.hs by Emacs `code movements'. Once the syntax errors have been fixed, the code worked on the first try. One can easily define a yet another interpreter, to convert the formatting specification to a C-like format string.

Linking Multiple Versions of the Same Package

Ashley Yakeley — 2008-09-01T09:58:35

I tried doing this out of curiosity. Package B links to version 0.1 of open-witness, while package C links to B and version 0.1.1 of open-witness. Cabal stopped me when doing "cabal configure" in C: $ cabal configure Configuring C-0.1... Warning: This package indirectly depends on multiple versions of the same package. This is highly likely to cause a compile failure. package B-0.1 requires open-witness-0.1 package C-0.1 requires open-witness-0.1.1 It appears the issue is that package versions are not recorded in External Core names. Thus

The initial view on typed sprintf and sscanf

2008-09-01T02:40:41

We demonstrate typed sprintf and typed sscanf sharing the same formatting specification. Our solution is surprisingly trivial: it defines a simple embedded domain-specific language of formatting patterns. The functions sprintf and sscanf are two interpreters of the language, to build or parse a string according to the given pattern. Our solution relies only on GADTs. We demonstrate that lambda-abstractions at the type level are expressible already in the Hindley-Milner type system; GADT with the included polymorphic recursion help us use the abstractions. The typed sprintf takes the formatting specification and several arguments and returns the formatted string. The types and the number of arguments depend on the formatting specification. Conversely, the typed sscanf parses a string according to the formatting specification, passing parsed data to a consumer function. Again, the number and the types of the arguments to the consumer depend on the formatting specification. The typed sprintf problem has been investigated extensively: the first solution was shown by Danvy; more solutions were proposed by Hinze and Asai. The typed scanf problem received significantly less attention, if any. It seems that the implementation of the typed sprintf and sscanf sharing the same formatting specification has not been known. Here are a few examples of the typed sprintf and sscanf A formatting specification is built by connecting primitive specifications (such as lit "string", int, char) with (^). We observe that whereas sprintf $ lit "Hello world" has the type String, sprintf $ lit "The value of " ^ char ^ lit " is " ^ int has the type Char -> Int -> String. Likewise, the type of the consumer of the values parsed by sscanf varies with the formatting specification. The example of tp3 and ts3 demonstrates that sprintf and sscanf can indeed use exactly the same formatting specification, which is a first-class value. Printf and scanf are present in many languages (e.g., C and Haskell); in most of the cases, they are not type-safe: the type checker does not stop the programmer from passing to printf more or fewer arguments than required by the formatting string. OCaml supports typed sprintf and sscanf, which relies on a particular weird typing of these functions, resulting in formatting specifications being not first class. Our sscanf has exactly the same interface as that in OCaml, modulo weird typing. The complete code of the typed sprintf and sscanf with more examples is available at http://okmij.org/ftp/Haskell/PrintScan.hs It can be used in Haskell programs as it is; it is trivial to arrange it in a Haskell library or Hackage package. Our implementation is based on the observation of Hinze (Ralf Hinze. Functional Pearl: Formatting: a class act. JFP, 13(5):935-944, September 2003) that the formatting specification is a `type transformer', a functor. For example, the formatting specification 'int' is associated with a functor transforming a type 't' to a type 'Int -> t'. Hinze represented functors in Curry style; the functor associated with 'int' is then (Int ->). However, a more direct, Church-style representation is also possible. Let us consider a type "F a b" where "F" is a binary type constructor, "a" is a type variable, and "b" is a type that may include one or more occurrences of "a". That type is essentially a type abstraction, the type-level lambda-function. To apply the function to an argument, we unify "a" with the argument; the second parameter of "F" is the result of the application. This is the standard emulation of lambda-calculus in Prolog. Based on this observation, we define the language of formatting specifications as follows: The type of (:^) expresses the inverse functional composition of two type-level lambdas; one may read "F" as `big lambda'. The formatting specification can be interpreted in two different ways, for printing and for parsing. The types of the interpreters are pleasingly symmetric: The printing interpretation implements Asai's accumulator-less alternative to Danvy's functional unparsing: http://pllab.is.ocha.ac.jp/~asai/papers/tr07-1.ps.gz The printing interpretation of (a :^ b) is string concatenation in CPS form. The sprintf and sscanf are then simple wrappers: The problem of the typed printf and scanf over the same formatting specification has been posed by Chung-chieh Shan in a discussion with Kenichi Asai and Yukiyoshi Kameyama. I'm grateful to them for inspiration.

TLDI 2009 Call for Papers

Amal Ahmed — 2008-09-01T02:18:30

_______________________________________________ Haskell mailing list Haskell< at >haskell.org http://www.haskell.org/mailman/listinfo/haskell

Final CFP and extended deadline IFL 2008

Sven-Bodo Scholz — 2008-08-26T17:26:38

******************************************************************************** * * FINAL CALL FOR PAPERS -- EXTENDED DEADLINE!! * CALL FOR PARTICIPATION * * 20th International Symposium on the * Implementation and Application of Functional Languages * IFL 2008 * 10-12.Sept 2008, Hatfield UK * * http://events.sac-home.org/ifl2008/ * ******************************************************************************** UPDATED DEADLINES: * Submission for draft proceedings: NOW 1. Sept * Early Registration: NOW 2. Sept Please note, that the draft proceedings do NOT require full papers; extended abstracts will be considered too. ******************************************************************************** The aim of the IFL symposia is to bring together researchers actively engaged in the implementation and application of functional and function-based programming languages. They provide an open forum for researchers who wish to present and discuss new ideas and concepts, work in progress, preliminary results, etc. related primarily but not exclusively to the implementation and application of functional languages. Formal proceedings are produced after the symposium, so that authors can incorporate the feedback from discussions at the symposium in their published papers. Topics ====== Topics of interest include, but are not limited to: * language concepts * type checking * compilation techniques * (abstract) interpretation * generic programming techniques * automatic program generation * array processing * concurrent/parallel programming * concurrent/parallel program execution * functional programming on embedded systems * functional programming on multi-cores/ many-cores * heap management * runtime profiling * performance measurements * debugging and tracing * (abstract) machine architectures * verification * formal aspects * tools and programming techniques Papers on applications or tools demonstrating the suitability of novel ideas in any of the above areas and contributions on related theoretical work are also welcomed. The change of the symposium name adding the term application, introduced in 2004, is to reflect the broader scope IFL has gained over the years. Paper Submissions ================= Prospective authors are encouraged to submit papers 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 School of Computer Science of the University of Hertfordshire. Attendees of IFL 2008 will have the opportunity to submit a revised version of their paper for post-symposium reviewing. As in previous years, we hope that selected papers will be published by Springer Verlag in the Lecture Notes in Computer Science (LNCS) Series. The Peter Landin Prize ====================== Since 2002 every year the Peter Landin Prize of 150 GBP is awarded to the best paper presented at the symposium, as selected by the program committee. Important Dates =============== * Submission for draft proceedings: NOW 1. Sept. * Early Registration: NOW 2. Sept. * Symposium: 10-12. September * Submission for post-refereeing: 14. November * Notification of acceptance / rejection: 23. January 2009 * Submission of a camera ready version: 20. February 2009 Contact ======= For further details see or contact us by email: events sac-home.org

Top Level <-

Ashley Yakeley — 2008-08-24T23:12:18

Is there any interest in implementing a top level "<-" to run monadic code? Currently this sort of thing is done with unsafePerformIO and switching off inlining with some pragma. Indeed, the 'atomically' haddock actually advises doing this to declare top-level TVars. The same trick is used in the source of Data.Unique and System.Random. This is bad Haskell. To avoid observation of effects, etc., we would need a new monad rather than IO. There would be equivalents of IO functions such as these: newIORef newMVar newTVarIO newUnique I can think of two uses: 1. Global mutable state. For instance, here's the count variable for Data.Unique rewritten: uniqSource :: MVar Integer uniqSource <- newMVarTL 0 Isn't that much nicer? 2. Solving the expression problem using open witnesses, a recent hobby-horse of mine. For instance, here's a simple scheme for extensible exceptions using top-level "<-": -- declare exception carrying an Int myException :: Exn Int <- newExn -- throw with 5 foo = do ... throw myException 5 -- catch, print the Int bar = catch foo myException (\i -> putStrLn (show i)) I already have code for this, except with an unsafe hack to do the "<-" declaration: My open-witness package, which also shows how to do Typeable/Dynamic safely:

Another First course in Haskell

Piyush P Kurur — 2008-08-22T03:53:47

Hi, I am planing a haskell based functional programming course. It is supposed to be a first course and I intend to show how real world applications can be built quite easily in haskell. Goals: 1) Cover all the basics like recursion, interesting data structures like zippers, monads 2) Haskell programming environment: by this I mean things like ghci, hadock, cabal The students after the course should seriously consider Haskell as a programming language for implementing their final year projects. In this aspect if one can convince that things like web-programming cgi scripting, networking, compiler projects, which are the favorits for programming projects, are better done in Haskell than in traditional languages like C and Java that would be a success. The course will be taken by mostly Computer Science undergrads. Any feed back is really welcome. I have about 2-3 months to plan the course. Regards ppk

ANNOUNCE: Lava2000 on Hackage

Emil Axelsson — 2008-08-20T15:40:43

Hello, Lava2000 has been uploaded to Hackage: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/chalmers-lava2000 Lava is a structural hardware description library embedded in Haskell. This version of Lava focuses on verification, and connects to a number of different verification engines (although only Smv and Satzoo are maintained in this version). For documentation, see the tutorial included in the package. The code is located at http://www.cs.chalmers.se/~emax/darcs/chalmers-lava2000/ People who have other modified versions of the library are welcome to submit patches, so that we get a single version that can be used by everyone. A different version of Lava, with focus on FPGA generation, can be found on Satnam Sing's page: http://raintown.org/lava/ / Emil

QuickCheck and HPC Tutorial

Andy Gill — 2008-08-20T14:53:55

_______________________________________________ Haskell mailing list Haskell< at >haskell.org http://www.haskell.org/mailman/listinfo/haskell

Compiler Construction course using Haskell?

Johannes Waldmann — 2008-08-20T14:03:42

_______________________________________________ Haskell mailing list Haskell< at >haskell.org http://www.haskell.org/mailman/listinfo/haskell

Is this a feature or bug in the GADTs &ExistentialQuantification? (Was: [Haskell-cafe] UnboxingVT_VARIANT in hscom)

Krasimir Angelov — 2008-08-20T09:35:15

The issue reported by Praki looks like a GHC bug to me. The smallest test case is at the end. (VarType a) is a GADT and Variant wraps the VarType with a value of type a. The definitions of Variant and VarType require ExistentialQuantification and GADTs extensions and I have declared them. The problem is when someone try to use them. If the client code is compiled without any extensions turned on the error message is: This suggests that the compiler understands that Variant is an existential type but doesn't understand that VarType is a GADT. If the code is compiled with -fglasgow-exts then everything works fine. Why the compiler always understands existential types and not GADT. For me this is unfair against GADT. Shouldn't the compiler always understand GADT as well provided that they are already defined somewhere? Best Regards, Krasimir ------------------------------------------------------------------------------

ANN: witness 0.1, open-witness 0.1,"Witnesses and Open Witnesses"

Ashley Yakeley — 2008-08-18T08:27:46

Two packages, and the draft paper on which they are based. Both packages are "proof of concept"; I'm open to ideas and repainting of bike-sheds. witness 0.1 A witness is a value that witnesses some sort of constraint on some list of type variables. This library provides support for simple witnesses, that constrain a type variable to a single type, and equality witnesses, that constrain two type variables to be the same type. The library also provides classes for representatives, which are values that represent types. For example, the equality witness type: data EqualType a b where MkEqualType :: EqualType t t If two simple witness values are the same, then their types are the same: class SimpleWitness w where matchWitness :: w a -> w b -> Maybe (EqualType a b) Hackage: Source: open-witness 0.1 Open witnesses (type IOWitness) are simple witnesses that can witness to any type. However, they cannot be constructed, they can only be generated in certain monads: newIOWitness :: IO (IOWitness a) We can also create fully heterogenous dictionaries that use open witnesses as keys. This would work as the state in an ST monad. If we had a "top-level" monad, or some other way of declaring unique IOWitness values at top level, we could straightforwardly and safely solve the expression problem (see below). In lieu of that, there's an unsafe function to construct them: unsafeIOWitnessFromString :: String -> IOWitness a This release includes an example re-implementation of ST/STRef, and a sound approximation of Typeable/Dynamic. Hackage: Source: Witnesses and Open Witnesses Abstract: We review witnesses, an emerging Haskell idiom, and suggest some terminology. We then introduce open witnesses as a library, and propose an extension to allow the creation of them at top-level. We show how this solves the expression problem, all with relatively little implementation fuss. draft, rejected from the Haskell Symposium 2008

CFP: PADL 2009

Andy Gill — 2008-08-14T15:58:42

CALL FOR PAPERS!!! Eleventh International Symposium on Practical Aspects of Declarative Languages 2009 (PADL '09) http://cs.utdallas.edu/padl09/ Savannah Georgia, USA January 19-20, 2009 Co-located with ACM POPL'09 Declarative languages build on sound theoretical bases to provide attractive frameworks for application development. These languages have been successfully applied to vastly 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: * innovative applications of declarative languages; * declarative domain-specific languages and applications; * practical applications of theoretical results; * new language developments & their impact on applications; * evaluation of implementation techniques on practical applications; * novel uses of declarative languages in the classroom; and * practical experiences PADL 09 welcomes new ideas and approaches pertaining to applications and implementation of declarative languages. PADL 09 will be co-located with the ACM POPL. IMPORTANT DATES AND SUBMISSION GUIDELINES Paper Submission:September 8, 2008 Notification:October 10, 2008 Camera-ready:November 5, 2008 Symposium:January 19-20, 2009 Authors should submit an electronic copy of the full paper (written in English) in Postscript (Level 2) or PDF, in the Springer LNCS format (see http://www.springeronline.com/lncs/ ). In addition to the technical papers of previous PADL conferences, PADL 09 will contain a streamk for application papers. TECHNICAL PAPERS Technical papers must describe original, previously unpublished results, and must not be simultaneously submitted for publication elsewhere. Each submission must be written in English, and include three to four keywords, which will be used to assist us in selecting appropriate reviewers for the paper. Submissions must not exceed 15 pages in Springer LNCS format. APPLICATION PAPERS 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 poster 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 technical 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 Lennart Augustsson Credit Suisse (UK) Hasan Davulcu Arizona State University (US) Inés Dutra Universidade do Porto (PT) John Gallagher Roskilde University (DK) Andy Gordon Microsoft Research (UK) Jeff Gray University of Alabama at Birmingham (US) Kevin Hamlen University of Texas at Dallas (US) Fergus Henderson Google (US) Gabriele Keller University of New South Wales (Australia) Michael Kifer SUNY Stony Brook (US) Ilkka Niemelä Helsinki University of Technology (FI) Johan Nordlander Luleå University of Technology (Sweden) Luís Pereira Universidade Nova de Lisboa (PT) Tom Schrijvers Katholieke Universiteit Leuven (BE) Lindsey Spratt Onology Works (US) Don Stewart Galois, Inc (US) Walter Wilson Systems Development and Analysis (US) Contacts: For information about papers and submissions, please contact a Program Chair: Andy Gill PC co-Chair - PADL 2009 Dept. of Electrical Engineering & Computer Science The University of Kansas 2001 Eaton Hall 1520 West 15th Street Lawrence, KS 66045-7621 Email: andygill ku.edu Terrance Swift PC co-Chair - PADL 2009 Centre for Artificial Intelligence (CENTRIA) Departamento de Informática, FCT/UNL Quinta da Torre 2829-516 CAPARICA - Portugal Email: tswift cs.sunysb.edu For other information about the conference, please contact: Kevin Hamlen General Chair - PADL 2009 Department of Computer Science University of Texas at Dallas Richardson, TX, USA Email: hamlen utdallas.edu

FW: shootout on quad-core

Simon Peyton-Jones — 2008-08-13T08:09:38

Friends: an opportunity spotted by Ulf. Simon -----Original Message----- From: ulf.wiger< at >gmail.com [mailto:ulf.wiger< at >gmail.com] On Behalf Of Ulf Wiger Sent: 12 August 2008 16:33 Subject: shootout on quad-core The famous language shootout now has a quad-core architecture: http://shootout.alioth.debian.org/u64q/benchmark.php?test=all&lang=all So far, the maintainers have mainly focused on trying to get the build environment to work, and no real agreement exists on how to potentially expand the benchmark suite with multicore problems, or perhaps how to handle alternative entries on existing benchmarks. I think they welcome suggestions. I imagine that several different categories exist: - problems that naturally lend themselves to message-passing concurrency - obviously data parallel algorithms - problems that could be parallelized using a smart compiler BR, Ulf W

CFP: PLPV 2009

Wouter Swierstra — 2008-08-09T18:02:36

Dear all, I'd like to encourage you to submit something to "Programming Languages meet Program Verification". The PC would love to see examples of verified Haskell programs and innovative uses of Haskell's type system. Wouter Call For Papers Programming Languages meets Program Verification (PLPV) 2009 http://sneezy.cs.nott.ac.uk/darcs/plpv09 January 20, 2009 Savannah, Georgia, USA Affiliated with POPL 2009. Invited Speaker: Manuel Fahndrich, Microsoft Research Overview: The goal of PLPV is to foster and stimulate research at the intersection of programming languages and program verification. Work in this area typically attempts to reduce the burden of program verification by taking advantage of particular semantic and/or structural properties of the programming language. One example are dependently typed programming languages, which leverage a language's type system to specify and check richer than usual specifications, possibly with programmer-provided proof terms. Another example are extended static checking systems like Spec#, which extends C# with pre- and postconditions along with a static verifier for these contracts. Paper Topics: We invite submissions on all aspects, both theoretical and practical, of the integration of programming language and program verification technology. By co-locating with POPL 2009, we seek to broaden the scope of PLPV. For example, submissions may have diverse foundations for verification (e.g., type-based, Hoare-logic-based), target diverse kinds of programming languages (e.g., functional, imperative, object-oriented), and apply to diverse kinds of program properties (e.g., data structure invariants, security properties, temporal protocols). Submissions: Submissions should fall into one of the following three categories: 1. Regular research papers (at most 12 pages in total length). Submissions in this category should describe new work on the above or related topics. Please note that the page limit is an upper limit - shorter submissions are encouraged. 2. Work-in-progress reports (at most 6 pages in total length). Submissions in this category should describe new work that is ongoing and may not be fully completed or evaluated. 3. Proposals for challenge problems (at most 6 pages in total length). Submissions in this category should describe an application area which the author believes is a useful benchmark or important domain for language-based program verification techniques. Submissions should be prepared with SIGPLAN two-column conference format. Submitted papers must adhere to the SIGPLAN republication policy. Concurrent submissions to other workshops, conferences, journals, or similar forums of publication are not allowed. Publication: Accepted papers will be published by the ACM and appear in the ACM digital library. Important Dates: * Electronic submission: October 8, 2008, 11:59 pm, Samoa time (UTC-11) * Notification: November 8, 2008 * Final version: November 17, 2008 * Workshop: January 20, 2009 Organizers: * Thorsten Altenkirch (University of Nottingham, UK) * Todd Millstein (University of California, Los Angeles, USA) Program Committee: * Andreas Abel (University of Munich, Germany) * Thorsten Altenkirch, co-chair (University of Nottingham, UK) * Jeremy Gibbons (University of Oxford, UK) * Robert Harper (Carnegie Mellon University, USA) * K. Rustan M. Leino (Microsoft Research, USA) * Todd Millstein , co-chair (University of California, Los Angeles, USA) * Ulf Norell (Chalmers University, Sweden) * Jeremy Siek (University of Colorado, Boulder, USA) * Benjamin Werner (Ecole Polytechnique, France) * Steve Zdancewic (University of Pennsylvania, USA)

2nd call for papers IFL 2008

Sven-Bodo Scholz — 2008-08-08T03:39:41

******************************************************************************** * * CALL FOR PAPERS * * 20th International Symposium on the * Implementation and Application of Functional Languages * IFL 2008 * 10-12.Sept 2008, Hatfield UK * * http://events.sac-home.org/ifl2008/ * ******************************************************************************** The aim of the IFL symposia is to bring together researchers actively engaged in the implementation and application of functional and function-based programming languages. They provide an open forum for researchers who wish to present and discuss new ideas and concepts, work in progress, preliminary results, etc. related primarily but not exclusively to the implementation and application of functional languages. Formal proceedings are produced after the symposium, so that authors can incorporate the feedback from discussions at the symposium in their published papers. Topics ====== Topics of interest include, but are not limited to: * language concepts * type checking * compilation techniques * (abstract) interpretation * generic programming techniques * automatic program generation * array processing * concurrent/parallel programming * concurrent/parallel program execution * functional programming on embedded systems * functional programming on multi-cores/ many-cores * heap management * runtime profiling * performance measurements * debugging and tracing * (abstract) machine architectures * verification * formal aspects * tools and programming techniques Papers on applications or tools demonstrating the suitability of novel ideas in any of the above areas and contributions on related theoretical work are also welcomed. The change of the symposium name adding the term application, introduced in 2004, is to reflect the broader scope IFL has gained over the years. Paper Submissions ================= Prospective authors are encouraged to submit papers 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 School of Computer Science of the University of Hertfordshire. Attendees of IFL 2008 will have the opportunity to submit a revised version of their paper for post-symposium reviewing. As in previous years, we hope that selected papers will be published by Springer Verlag in the Lecture Notes in Computer Science (LNCS) Series. The Peter Landin Prize ====================== Since 2002 every year the Peter Landin Prize of 150 GBP is awarded to the best paper presented at the symposium, as selected by the program committee. Important Dates =============== * Submission for draft proceedings: 22. August * Early Registration: 25. August * Symposium: 10-12. September * Submission for post-refereeing: 14. November * Notification of acceptance / rejection: 23. January 2009 * Submission of a camera ready version: 20. February 2009 Contact ======= For further details see or contact us by email: events sac-home.org

ANN: interval and polynomial enclosure arithmetics

Michal Konecny — 2008-08-07T18:37:46

_______________________________________________ Haskell mailing list Haskell< at >haskell.org http://www.haskell.org/mailman/listinfo/haskell

DEFUN 2008 (Developer Tracks on Functional Programming):Call for participation

Matthew Fluet (ICFP Publicity Chair — 2008-08-07T01:37:58

ACM SIGPLAN 2008 Developer Tracks on Functional Programming http://www.deinprogramm.de/defun-2008/ Victoria, BC, Canada, 25, 27 September, 2008 Held in conjunction with ICFP 2008: http://www.icfpconference.org/icfp2008/ DEFUN 2008 is the event for developers using functional languages: Recognized experts on functional programming technologies share their knowledge and professional skills in talks and tutorials in 10 exciting tracks. Find out how to best make functional programming work in your development project! Acquire new development skills! Learn about other functional languages! The DEFUN program (attached) has tracks with the following types of presentations: - Half-day general language tutorials for specific functional languages, given by recognized experts for the respective languages. - Half-day tutorials on specific techniques or the use of specific technologies in functional programming. - 45-minute "how-to" talks that provide specific information on how to solve specific problems using functional programming. These talks focus on concrete examples, but provide useful information for developers working on different projects or in different contexts. The developer tracks are complementary to ICFP itself (which is for researchers). They are anchored by CUFP, the Haskell Symposium, and the Erlang workshop. Organizers Kathleen Fisher AT&T Labs Simon Peyton Jones Microsoft Research Mike Sperber (co-chair) DeinProgramm Don Stewart (co-chair) Galois PROGRAM: Note: The sessions of a given morning or afternoon are concurrent. The markers (M1, M2, A1, A2, etc.) mark a particular session, and correspond to the designations on the registration forms. Note that the talks M5 together constitute a session. DAY 1 - 25 SEPTEMBER, 2008 MORNING SESSION M1 (Tutorial): Practical Erlang Programming Francesco Cesarini Erlang Training and Consulting M2 (Tutorial): A Gentle Introduction to Functional Information Visualization Jefferson Heard Renaissance Computing Institute, University of North Carolina M3 (Tutorial): JavaScript: from basics to building custom frameworks Sameer Sundresh and Erik Hinterbichler University of Illinois Urbana-Champaign and Pattern Insight, Inc. AFTERNOON SESSION A1 (Tutorial): Erlang DBG and the Trace Biff Tamas Nagy Erlang Training and Consulting A2 (Tutorial): Erlang QuickCheck Tutorial Thomas Arts IT University of Gothenburg and Quviq A3 (Tutorial): Practical and Portable Programming in Scheme Donovan Kolbly TippingPoint Technologies DAY 2 - 27 SEPTEMBER 2008 MORNING SESSION M4 (Tutorial): Real World Haskell Bryan O'Sullivan M5 (Talks): Ten one-liners: handling power series in Haskell Doug McIlroy Dartmouth Incremental multi-level input processing with left-fold enumerator Oleg Kiselyov How we locate wild animals with a functional program Ryan Newton MIT AFTERNOON SESSION A4 (Tutorial): Using QuickCheck and HPC - Obtaining Quality Assurance for Haskell Code Andy Gill Kansas University Koen Claessen Chalmers A5 (Tutorial): Introduction to F# Don Syme and Chris Smith Microsoft Research