Haskell Weekly News: November 28, 2006

Submitted by dons on Mon, 11/27/2006 - 6:53pm.

Welcome to issue 51 of HWN, a weekly newsletter covering developments in the Haskell community.

Automated testing fever strikes the camp, with three new QuickCheck-related libraries and tools released.

Announcements

  • QuickCheck 2 development version. Bjorn Bringert announced that the development version of QuickCheck 2 is now available in a public darcs repository. Highlights of the new QuickCheck version include: shrinking of failing test cases; supports testing monadic code; handles exceptions gracefully; coarbitrary has moved to a separate class; type-level modifiers for changing test data generation (e.g. NonNegative); function table printing; and user-defined actions when properties fail. The source is available via darcs.

  • PQC: QuickCheck in the Age of Concurrency. Don Stewart announced PQC: Parallel QuickCheck. PQC provides a single module: Test.QuickCheck.Parallel. This is a QuickCheck driver that runs property lists as jobs in parallel, and will utilise as many cores as you wish, with the SMP parallel GHC 6.6 runtime. It is simple, scalable replacement for Test.QuickCheck.Batch.

  • cabal-test: automatic testing for Cabal projects. David Himmelstrup announced cabal-test, the automatic tester for Cabal projects. The cabal-test tool is capable of testing embedded QuickCheck properties in any and all cabalized projects. The tests are currently executed in parallel with PQC. QuickCheck properties can reside anywhere in the code and don't have to be exported. The darcs repo is available.

  • Streams 0.1.7. Bulat Ziganshin announced Streams version 0.1.7, a fast extensible I/O and serialization library. Changes include: GHc 6.6 support, support for files larger than 4G on Windows, haddock documentation.

  • Ranged Sets 0.0.3. Paul Johnson announced the 0.0.3 release of Ranged Sets. Ranged sets allow programming with sets of values described by a list of ranges. A value is a member of the set if it lies within one of the ranges. The ranges in a set are ordered and non-overlapping, so the standard set operations can be implemented by merge algorithms in O(n) time.

  • Type-class overloaded functions. Oleg Kiselyov presented functions polymorphic over classes of types. Each instance of such (2-polymorphic) function uses ordinary 1-polymorphic methods, to generically process values of many types, members of that 2-instance type class. The typeclass constraints are thus manipulated as first-class entities. We also show how to write typeclass instances with back-tracking: if one instance does not apply, the typechecker will chose the `next' instance -- in the precise meaning of `next'.

  • Cabal mode for emacs. Matthew Danish released a small (and developing) major mode for editing Cabal files in emacs.

  • YCR2JS Programmers Guide Draft. Dimitry Golubovsky announced the draft of low-level programming guide for Yhc Core to Javascript converter. Everyone interested in future use of this tool is encouraged to read and review the Guide. Its purpose is to give some ideas about interaction of Haskell programs converted into Javascript with a web browser on the lowest possible level, without application frameworks and support libraries (just because these haven't been developed).

  • NeHe Tutorials in Haskell. Jason Dagit announced the availability of the (somewhat) famous NeHe tutorials for OpenGL have been ported to HOpenGL. A darcs repository is provided.

Haskell'

This section covers the Haskell' standardisation process.

Discussion

  • The Future of MissingH. John Goerzen opened a discussion on the future development of MissingH, in order to improve usability and adoption by the community. It was felt that the current monolithic structure, and nondescript naming raises the barrier to use.

  • Controlling backtracking with the list monad. Isto posed an interesting question about whether the backtracking in a list monad could be controlled, producing a nice way to build branch and bounding algorithms

  • Lifting conditionals. Dougal Stanton asked about lifting if/then/else into the IO monad, revealing some interesting subtleties in the implementation

  • Cheap commits for improving the library documentation. Don Stewart created a new page, for non-core contributors to submit suggestions on improving library documentation. Rather than require the user to produce a darcs patch, than can instead add their change to the wiki page. Ideally, a wiki-editable version of the entire haddock docs would be desired

  • Optimising a hash function. Ivan Tomac asked about optimising low-level bit shifting code to run close to C speed.

  • Common subexpression elimination. Christian Maeder asked about common subexpression elimination in GHC.

  • Passing arrays between Haskell and C without overhead. Brian Hulley asked for advice on how best to bind to a C library, from Haskell, such that data can be passed with zero copying.

  • Creating Loadable Dynamic libraries Libraries in OSX. Alfonso Acosta described how to create dynamic loadable libraries (.so) with GHC 6.6 under Linux X86 using some C glue code and linking with -optl -shared. Advice was sought on porting this to OSX.

Conference roundup

Fun in the Afternoon
  • Links: web programming without tiers. Phil Wadler.

  • Mechanized Metatheory Model-Checking. James Cheney. Syntactic techniques based on operational semantics and type systems are extremely useful for studying the metatheory of logics and programming languages. However, proving properties of such systems is often an onerous task, because there are often a large number of 'standard' or straightforward cases. It is tempting to cut corners and do careful proofs only for cases that seem interesting, but this can easily lead to a counterexample being missed. It therefore seems attractive to try to formalize such proofs in order to ensure their validity. However, this cure is often worse than the disease, since theorem proving tools tend to have a high learning curve. Moreover, theorem proving generally addresses the uncommon case of formalizing an informal proof of a well-understood system which has stood the test of time, rather than the common case of finding a bug in a poorly-understood system that may still be under development.

  • A Principled Approach to Version Control. Wouter Swierstra. Version control systems are essential for managing the distributed development of large software pro jects. We present a formal model for reasoning about version control. In particular, we give a general definition of patch. Patches abstract over the data on which they operate, making our framework equally suited for version control of everything from highly-structured XML files to blobs of bits. We model repositories as a multiset of patches. The mathematical definitions of patches and repositories enable us to reason about complicated issues such as conflicts and conflict resolution.

  • C\# is a functional programming language. Andrew Kennedy. Polymorphic functions, parameterized types, lambda expressions, type inference, streams, GADTs, and combinator libraries: these are features usually associated with functional languages such as Haskell and ML. In this talk I will show how the design of C\# 3.0, launching next year, was strongly influenced by ideas from functional programming, and supports all these features. I will use classic examples from the functional programming literature to illustrate the talk.

Blog noise

Haskell news from the blogosphere.

Quotes of the Week

  • Cale: GADT pattern match in non-rigid context. There are prescriptions available for that sort of thing.
  • Bulat: Base lib includes everything, from 'const' to starship control
  • Cale: I should actually think before coding, but the type system is so good.
  • Syzygy-: Why do I get the feeling that the arrow code was written during 'Speak like a pirate day'?
  • SamB: [on the subject of fromJust] thinks that unJust would be a more fun name for that
  • apfelmus: Ah, yet another UndeadArray necromancer exhausting his stack of bones. May the forces of light suggest to structure the incantation of darkness?
  • dons: Ah, it *is* like Haskell. I see: Jiffy Pop is the family fun treat. No other brand of popcorn offers a self-contained popping pan. It can even be used outdoors.
  • thetallguy: Using and advocating Haskell is like being Calvin (and Hobbes). To you, it's alive, real, a true delight. To those who know better, it's a stuffed tiger.

Code Watch

  • Mon Nov 27 05:06:02 PST 2006. Wolfgang Thaller. Initial support for x86_64-darwin. Basic -fvia-C code generation is there, not much testing.

  • Fri Nov 24 15:05:48 PST 2006. simonpj. Fix constraint handling for lazy patterns. Lazy patterns are quite tricky! Consider f ~(C x) = 3. Can the Num constraint from the 3 be discharged by a Num dictionary bound by the pattern? Definitely not! See Note 'Hopping the LIE in lazy patterns' in TcPat. The type checker wasn't ensuring this, and that was causing all manner of strange things to happen. It actually manifested as a strictness bug reported by Sven Panne.

About the Haskell Weekly News

Each week, new editions are posted to the Haskell mailing list as well as to the Haskell Sequence and Planet Haskell. RSS is also available, and headlines appear on haskell.org. Headlines are available as PDF. The Haskell Weekly News is also available in Spanish translation.

To help create new editions of this newsletter, please see the contributing information. Send stories to dons at cse.unsw.edu.au. The darcs repository is available at darcs get http://www.cse.unsw.edu.au/~dons/code/hwn

Haskell Weekly News: November 22, 2006

Submitted by dons on Wed, 11/22/2006 - 6:32am.

Welcome to issue 50 of HWN, a weekly newsletter covering developments in the Haskell community.

This week a new release of the Haskell XML Toolbox, and details for the inaugural Haskell Hackathon are announced. And the HWN half century of issues is on the board!

Announcements

  • Haskell XML Toolbox 7.0. Uwe Schmidt released a new version of the Haskell XML Toolbox. New in 7.0 is a module for XSLT transformation. The XSLT module implements most of the XSLT standard. The development of the XSLT module is done by Tim Walkenhost in his master thesis, describing the design of the transformer (and the limitations) is included in the distribution. HXT 7.0 works with ghc-6.4 and ghc-6.6. A tutorial is available in the Haskell wiki.

  • Hac: Haskell Hackathon 2007. The Hac organisers announced that the inaugural Haskell Hackathon, Hac 2007, will be held at Oxford University Computing Laboratory, January 10-12, 2007. The plan is to hack on Haskell infrastructure, tools, libraries and compilers. To attend please register, and get ready to hack those lambdas!

  • System.FilePath 0.11. Neil Mitchell announced the release of System.FilePath 0.11, a library for manipulating FilePath's correctly on both Posix and Windows.

  • Darcs release candidate. Tommy Pettersson announced it's time for a new darcs release candidate, 1.0.9rc2. There will probably be yet another release candidate (rc3) before final 1.0.9. Get testing!

  • Safe library 0.1. Neil Mitchell announced the release of Safe library, 0.1. People often have a problem with pattern match errors, and the only helpful message they get is: 'pattern match error'. The Safe library hopes to eliminate some of the frustration this causes by providing versions of these partial functions with more helpful error messages.

  • LocH, located errors 0.1. Don Stewart announced the release of LocH, a small Haskell module providing source location-specific error messages and debugging strings for Haskell code. It uses the compiler-expanded 'assert' token, rather than cpp or m4, to provide a lightweight approach to generating source locations. No preprocessor is required. More information is available at the LocH site, including API documentation.

  • Starting your own Haskell project. Jason Dagit and Don Stewart expanded on the document describing how best to set up a new Haskell project, leading to the creation of mkcabal,a new tool for setting up cabalised Haskell projects.

Haskell'

This section covers the Haskell' standardisation process.

Libraries

This week's proposals and extensions to the standard libraries.

Discussion

  • New Arrows tutorial. Tim Newsham wrote a small arrows tutorial, and is looking for feedback.

  • Yhc.Core backends for Haskell/Javascript/C. Neil Mitchell asked about the direction the Yhc Core backends should take.

  • The Burrows Wheeler Transformation. Jon Fairbairn proposed a game to find the most elegant implementation of the Burrows Wheeler transformation and its inverse.

  • More fusion. Claus Reinke described a method for avoiding the O(n) overhead of cons in strict ByteStrings. Some alternative strategies were also suggested.

  • Extending TypeEq: topEq for types. Nicolas Frisby described a solution to an interesting type problem using TypeEq, Oleg followed up with an alternate solution

  • Debugging by the rules. Don Stewart described an idea to use rewrite rules to change mysterious failing functions to more useful variants. More details on using rewrite rules for various ticks have been collected on the wiki.

  • Generalising zip. Jason Dagit wondered about a generalisation of zip to encode functions like isPrefixOf

  • Heterogeneous collections. Valentin Gjorgjioski asked about techniques for heterogeneous data in Haskell. Several solutions were suggested, and a new wiki page collects the details.

Blog noise

Haskell news from the blogosphere.

Quotes of the Week

  • Larry Wall: People who succeed in brushing up on Haskell do so by brushing up lazily.
  • xerox: [dons] then again, bots themselves are simple. [xerox] '...they are just a morphism in the category of IRC channels together with an endomapping ...'
  • Dave Love: Presumably people with the taste to program in Haskell will use Emacs anyway.
  • Baughn: I know I always have trouble explaining what the weather is like without involving foldr somehow.
  • Korollary: Darcs is free of chemical toxins of big pharma. It's made using all natural herbs and other woo. It's good for you. Cheers.
  • Pseudonym: A 'newbie', in Haskell, is someone who hasn't yet implemented a compiler. They've only written a monad tutorial.
  • astrolabe: I guess missile launching would have to be in IO
  • dons: Java's type system is unsuitable for young children, the elderly or infirm of constitution
  • earthy: The Haskell standard Prelude is ... a treasure trove. But it does require breaking your mind and reassembling the pieces to unlock the trove.
  • emu: Hijack the stack and take this compiler to Fun-land!
  • norpan: The comonad of the No monad is the Yes monad?
  • robreim: I'm in your base hacking all your lambdas
  • shapr: I was chatting with someone who writes Haskell and at some point they said they're not an academic, and I said that too. And then there was what I perceived to be a small disbelieving silence...
  • simonpj: Maybe if I had an Oleg implant I could express all this in the type system
  • skew: [On the subject of strictness] There is a sequet incantation.
  • ski: Please talk to your son or daughter about parametric polymorphism
  • wadler: The way we can tell it's C# instead of Haskell is because it's nine lines instead of two.

Code Watch

  • Wed Nov 8 09:14:52 PST 2006. Alexey Rodriguez. Addition of PAPI to the RTS. PAPI is a library that supports use of the performance counters built into most CPUs for measuring things like cache misses and branch mispredictions. Alexey Rodriguez has added support for PAPI to the RTS, so we can take measurements of any of the CPU performance counters during the run of a Haskell program, and we even separate out results for the GC from results for the mutator.

About the Haskell Weekly News

Each week, new editions are posted to the Haskell mailing list as well as to the Haskell Sequence and Planet Haskell. RSS is also available, and headlines appear on haskell.org. Headlines are available as PDF.

The Haskell Weekly News is also available in Spanish translation.

To help create new editions of this newsletter, please see the contributing information. Send stories to dons at cse.unsw.edu.au. The darcs repository is available at darcs get http://www.cse.unsw.edu.au/~dons/code/hwn

Haskell Weekly News: November 14, 2006

Submitted by dons on Mon, 11/13/2006 - 9:03pm.

Welcome to issue 49 of HWN, a weekly newsletter covering developments in the Haskell community.

This week we see the announcement of a Haskell to Javascript compiler project, and the overhaul of GHC's typeclass machinery is complete.

Announcements

  • Compiling Haskell to Javascript: YCR2JS. Dimitry Golubovsky announced Ycr2js, a sub-project within the York Haskell Compiler (Yhc) project. It is aimed to create a tool to convert an arbitrary Haskell program into Javascript which in turn may be executed in any Web browser. With great amount of help from the Yhc Team, the converter has been integrated into the Yhc project, and initial stage of coding and development has been completed. More documentation.

  • System.FilePath 0.10. Neil Mitchell announced System.FilePath 0.10, which hopefully is pretty close to final. This library manipulates FilePath's correctly on both Posix and Windows.

  • Major typeclass overhaul. Simon Peyton-Jones mentioned that for some time he has been promising an overhaul of GHC's type inference machinery to fix the interactions between type classes and GADTs. This overhaul has now been completed, and user-visible changes are summarised, including: GHC's type inference becomes complete, the restriction that every constraint in a type signature must mention at least one of the quantified type variables is lifted, dictionaries are packaged in data constructors and the proper interaction between GADTs and type classes is now respected.

  • Implementing the lambda calculus. Lennart Augustsson wrote about implementing interpreters for the lambda-calculus in Haskell, to experiment with different implementation methods.

  • Great language shootout: reloaded. Don Stewart mentioned that now GHC 6.6 is available on the shootout machines, the time has come to improve the existing language shootout entries. Improvements can be posted to the wiki for review.

Haskell'

This section covers the Haskell' standardisation process.

Libraries

This week's proposals and extensions to the standard libraries.

Discussion

  • Choosing a Haskell GUI library. Bulat Ziganshin asked for advice on which Haskell gui library to use. Several suggestions were made.

Conference roundup

Asian Symposium on Programming Languages and Systems (APLAS 2006)
  • Type Processing by Constraint Reasoning. Peter Stuckey. Paper.

  • Principal Type Inference for GHC-Style Multi-Parameter Type Classes. Martin Sulzmann, Tom Schrijvers and Peter J Stuckey. Paper.

  • Automatic Testing of Higher Order Functions. Pieter Koopman and Rinus Plasmeijer. Paper.

Jobs

  • Research position in spatial cognition (Haskell-related). Till Mossakowski announced the availability of a Doctoral Research Assistant / Postdoctoral Researcher position at the Universität Bremen, concerned with classification and formalization of qualitative spatial calculi, relations among these calculi, spatial ontologies, and route graphs. More information.

Blog noise

Haskell news from the blogosphere.

Quotes of the Week

  • dylan: I remember being introduced to lambdas (in perl) from the programming perl, 2nd edition book. I used them heavily ever since... like some kind of cocaine addiction.
  • jdunck: What's your safeword?
  • sketerpot: With very strict typing, you need an *unsafe*word.
  • Binkley: Can you represent 'more moronic than Slashdot' with a 32-bit integer?
  • Robert Dockins: A Turing-complete type-checker isn't enough! Our work is not complete until the parser is a universal machine as well!
  • dons: Disable the type checker in GHC for 6 months and we'd have 5 Haskell debuggers by the end of it.
  • lennart: System Verilog is one of the worst 'designs' I've ever seen. So I bet it will be popular
  • lispy: The biggest reason most developers I know don't fix a bug is because they don't know it exists yet
  • monochrom: Time flies like an arrow. Fruit flies like a banana. Syntax rules like a macro
  • robreim: [on the new #haskell lojban channel] Great, now we've got to start an IRC channel for lojban-speaking, Haskell-coding anarchists
  • syntaxfree: Yes, Wadlerman: Prince of Funktions

Code Watch

About the Haskell Weekly News

Each week, new editions are posted to the Haskell mailing list as well as to the Haskell Sequence and Planet Haskell. RSS is also available, and headlines appear on haskell.org.

The Haskell Weekly News is also available in Spanish translation.

To help create new editions of this newsletter, please see the contributing information. Send stories to dons at cse.unsw.edu.au. The darcs repository is available at darcs get http://www.cse.unsw.edu.au/~dons/code/hwn

Haskell Weekly News: November 08, 2006

Submitted by dons on Tue, 11/07/2006 - 10:41pm.

Welcome to issue 48 of HWN, a weekly newsletter covering developments in the Haskell community.

Announcements

  • SmallCheck 0.2. Colin Runciman announced that SmallCheck 0.2, a lightweight testing library for Haskell, is out, and can be obtained. Since version 0.1: there's now a choice of interactive or non-interactive test-drivers using iterative deepening; more pre-defined test-data generators, including revised Int, Integer, Float, Double, Nat and Natural and additional examples. SmallCheck is similar to QuickCheck but instead of testing for a sample of randomly generated values, SmallCheck tests properties for all the finitely many values up to some depth, progressively increasing the depth used.

  • Hoogle Command Line 3 Beta. Neil Mitchell released Hoogle Command Line version 3 Beta, an alternative to the Hoogle website. Hoogle lets you search for Haskell functions by name and by type signature.

  • The Monad.Reader. Wouter Swierstra issued a call for submissions for articles for the next issue of The Monad.Reader. There are a large number of conferences and journals that accept research papers related to Haskell; unfortunately, the platform for non-academic publications is far less developed. This is where The Monad.Reader fits in. So if you are tossing around some ideas, write it up, and submit! Deadline for submissions is January 19th, 2007.

  • Haskell Communities and Activities Report. Andres Loeh reminded us that the deadline for the November 2006 edition of the Haskell Communities and Activities Report is now! -- there may still be just enough time to make sure that the report contains a section on *your* project, on the interesting stuff that you've been doing; using or affecting Haskell in some way. For more info see the call for contributions.

  • HsMan. Frederik Eaton announced hsman, a tool that indexes Haddock-generated HTML files, and allows users to search for functions and also GHC manual topics.

  • HaL, Haskell meeting in Leipzig. Johannes Waldmann announced that a local Haskell meeting is to take place on December 5th in Leipzig, Germany. The meeting will be hosted by IBA Consulting. It will be quite informal, with some very short talks (most probably in German). Interessenten sind herzlich eingeladen. Details and (free) registration.

Haskell'

This section covers the Haskell' standardisation process.

Libraries

This week's proposals and extensions to the standard libraries.

Discussion

  • The OI comonad. Sven Biedermann invoked a discussion about the OI comonad, and provided an example of a simple OI-comonad for stdin/stdout only, that preserves referential integrity.

  • The Bits between the Lambdas. Nuno Pinto asked about Binary IO in Hakell. Several solutions were suggested.

  • Translating Haskell to VHDL. Alfonso Acosta pondered how to write a translator from Haskell to VHDL.

  • New maintainers for wxHaskell. Jeremy O'Donoghue announced that a new team of maintainers in place for wxHaskell, so we're hoping that will see a significant increase in wxHaskell activtiy in the future. Great!

  • Permutation with k levels. Nuno Pinto wondered about generic permute algorithms in Haskell.

Blog noise

Haskell news from the blogosphere.

Quotes of the Week

  • coffeemug: There don't seem to be any definitive sources that suggest Haskell isn't good at something.
  • stevan: Haskell is like all the other functional languages I have read about, but totally different at the same time
  • coffeemug: you can do more with Haskell in less code that's easier to read and maintain in the long run
  • Jeannette Wing: Computational thinking will have become ingrained in everyone's lives when ... trees are drawn upside down
  • monochrom: recursive directory search is an alpha-beta with boring values of alpha and beta
  • skew: Types are largely about writing down the contract of a function once and telling the compiler to keep track of things, rather than trying to get it all straight yourself, and being rewarded with bugs that only manifest during demos...
  • monochrom: They say Mozarts Mass in C minor K427 is uplifting. I'm going to name my next monad transformer or arrow transformer MozartMassInCMinorK427T
  • Ron Jeffries: Dan's assertion, as I recall it, was that Haskell lets us express the program 'in the way we think'. On the contrary, what Haskell does in my opinion is let us express the program in the way Haskell thinks
  • sedd: [On the improving Haskell and Lua scores on the language shootout] This is awesome. It's like watching a match between the team of the town where you're from, and the team of the town where you live. Either way you've got a reason to get drunk after the game.
  • emeijer: Functional programming has finally arrived to the masses. It's name is not Lisp, ML or Haskell: it's Visual Basic
  • audreyt: Because Haskell is such a reasonable language, we reason about it all the time, and we also have a bot to reason it for us when we are lazy
  • spiffy: needs to stop trying to understand monads at night
  • psykotic: spiffy: they're just monoids on the category of endofunctors over some category, what's the big deal?
  • skew: also, if you use ST you know the code is just using mutable variables, rather than formatting your hard drive
  • Baughn: I once explained monads to a non-programmer: 'And? What's so hard about that?'
  • monochrom: The problem is that bad programmers will assess tutorials for good programmers as 'ivory tower', and moreover bad programmers are the vocal majority. It gets you bad press
  • scodil: you say 'sledgehammer' like its a bad thing
  • sjanssen: I suspect that planet.haskell.org has more content on catamorphisms than cats

Code Watch

  • Wed Nov 1 08:43:29 PST 2006. Simon Peyton Jones. Major overhaul of the Simplifier. This big patch completely overhauls the Simplifier. The simplifier had grown old and crufty, and was hard to understand and maintain. This new version is still quite complicated, because the simplifier does a lot, but it's much easier to understand, for me at least.

About the Haskell Weekly News

Each week, new editions are posted to the Haskell mailing list as well as to the Haskell Sequence and Planet Haskell. RSS is also available, and headlines appear on haskell.org.

The Haskell Weekly News is also available in Spanish translation.

To help create new editions of this newsletter, please see the contributing information. Send stories to dons at cse.unsw.edu.au. The darcs repository is available at darcs get http://www.cse.unsw.edu.au/~dons/code/hwn

Haskell Weekly News: October 31, 2006

Submitted by dons on Mon, 10/30/2006 - 8:02pm.

Welcome to issue 47 of HWN, a weekly newsletter covering developments in the Haskell community.

This week we see a number of community documentation and maintenance efforts, and the appearance of indexed data types in GHC

Announcements

  • Associated data types in GHC. Manuel Chakravarty announced the availability of indexed data types, an extension of our earlier proposal for associated data types, in GHC's development version. Detailed information on where to get the right GHC and how to use indexed types is available from the Haskell wiki.

  • Yhc Bytecode library 0.3. Robert Dockins announced the release of the Yhc Bytecode library, version 0.3.

  • Haskell Program Coverage. Andy Gill checked the latest version of HPC, with GHC support, into the head GHC branch

  • Haskell Mersenne Twister. Lennart Augustsson made available his Haskell implementation of the Mersenne Twister random number generator.

  • Haskell-specific Google Search Engine. Don Stewart initialised a Haskell-specific search engine, as part of Google's coop engine system, which seems to do a good job of targeting just Haskell sites, in particular, mailing list items

  • A process for submitting library extensions. The libraries hackers have developed a document describing how to best go about contributing new code to the core Haskell libraries. On a similar note, the GHC team has prepared a page on best practice for GHC submissions.

  • How to create a Haskell project. Don Stewart and Ian Lynagh prepared some guidelines on starting your own Haskell project.

Haskell'

This section covers the Haskell' standardisation process.

Discussion

  • Haskell Quiz/Ruby Quiz. Haskell Hackers have started recording Ruby Quiz solutions on the Haskell wiki. Lots of fun puzzles are available, and its a useful resource if you're learning the language.

  • Infinite, open, statically constrained HLists. Oleg Kiselyov described heterogeneous sequences that admit infinite sequences and permits post-hoc addition of new elements, even to an already infinite sequence.

  • Lexically scoped type variables: new proposal. Ben Rudiak-Gould made a new proposal for scoped type variables.

  • Simple GADT parser for the eval example. Greg Buchholz sought advice on creating evaluators with GADTs

  • Package mounting. Frederik Eaton proposed an alternative design for package mounting extensions to the package system.

  • Function types as instances of Num. Greg Buchholz had an interesting problem using functions as instances of Num

  • Yhc Core file generation. Neil Mitchell suggested that it was time to start taking YHC Core output a bit more seriously, and made some proposals.

  • Parallelism in GHC 6.6 and seq vs. pseq. Simon Marlow noticed that Control.Parallel exports seq when in fact it should probably export pseq.

Jobs

  • Lectureships in Software Engineering. Jeremy Gibbons announced that applications are invited for three new University Lectureships in Software Engineering, at the University of Oxford. For further information, including full details of the application procedure and selection criteria, see here.

Blog noise

Haskell news from the blogosphere.

Quotes of the Week

  • Simon Marlow: In fact, you don't need an evil scheduler, an ordinary scheduler will do this.
  • Conor McBride: My operating hypothesis is that even ordinary schedulers are evil...
  • Larry Wall: Continuations - if you know what they are - I don't need to explain them. If you don't know what they are - you don't want to know.
  • Cale: [discussing names for Haskell, after suggesting Sapphire] Diamond: The Hardest Programming Language on Earth
  • ConorMcBride: So, taking Void to be the colour of the empty bikeshed ...
  • cjeris: I like how you conveniently gloss over the part where your head explodes.
  • dons: C++: Creating blub programmers since 1985
  • mwc: I can only believe that Java is a conspiracy perpetrated by keyboard manufacturers
  • Pseudonym: (:[]) looks like a ninja robot pirate monkey
  • chessguy: We've got satan and beelsebob in here, and talking about unicycling.... this channel is guaranteed to be a bad influence on me now
  • dons: fold (\water dish -> wash water dish) soapywater dishes
  • masklinn: Scheme, on the other hand, is dynamically compiled and thus doesn't 'fail early', it fails as late as it can, which produces weird error unless you're into testing. Beginners never are into testing.
  • Riastradh: Assume that I haven't the faintest idea of what a comonad is, beyond that if a monad goes `voob', then a comonad goes `boov'
  • Anonymous: It is quite possible that 'the ultimate teaching language' was not actually invented when Steele and Sussman came down from the mountain bearing a spool of 9-track magtape...
  • sigfpe: How can Haskell not be the programming language that all mathematicians should learn?
  • Syzygy: > let _'__'_'''_'__'_=2 in _'__'_'''_'__'_
  • ihope>: > let _' __ ___ (____:_____) = __ ____ (_' __ ___ _____); _' _ __ [] = __ in _' (+) 0
  • Syzygy: one thing that stands out is the relatively low distance between thought expressed in my ordinary day-to-day mathematical discourse, and thought expressed in Haskell code

Code Watch

  • Tue Oct 24 14:29:07 PDT 2006. Andy Gill. Haskell Program Coverage. This large checkin is the new ghc version of Haskell Program Coverage, an expression-level coverage tool for Haskell. You can run the coverage tool with -fhpc at compile time. Main must be compiled with -fhpc.

  • Tue Oct 24 02:13:57 PDT 2006. Simon Marlow. Split GC.c, and move storage manager into sm/ directory. In preparation for parallel GC, split up the monolithic GC.c file into smaller part

About the Haskell Weekly News

Each week, new editions are posted to the Haskell mailing list as well as to the Haskell Sequence and Planet Haskell. RSS is also available, and headlines appear on haskell.org.

The Haskell Weekly News is also available in Spanish translation.

To help create new editions of this newsletter, please see the contributing information. Send stories to dons at cse.unsw.edu.au. The darcs repository is available at darcs get http://www.cse.unsw.edu.au/~dons/code/hwn

Haskell Weekly News: October 24, 2006

Submitted by dons on Mon, 10/23/2006 - 7:39pm.

Welcome to issue 46 of HWN, a weekly newsletter covering developments in the Haskell community.

Announcements

  • MissingH 0.16.0. John Goerzen announced that the latest version of MissingH is now available. MissingH is a suite of 'missing' library functions. New features include: render numbers as binary units, a progress tracker, turn QuickCheck tests into HUnit tests, and GHC 6.6 support.

  • SMP parallel Pugs on GHC. Audrey Tang announced that parallel support, on top of GHC's new SMP runtime system, has been added to Pugs, the standard bearer Perl6 implementation.

  • YAHT is now a part of the wikibook. Eric Kow announced that the famous 'Yet Another Haskell Tutorial' has been imported into the Haskell wikibook. Let the great Haskell Remix begin!

Haskell'

This section covers the Haskell' standardisation process.

Discussion

  • Ruby puzzles. Jim Burton mentioned that he was working on the Ruby quiz puzzles in Haskell -- an interesting exercise.

  • DeepSeq and parallel strategies. Chad Scherrer started a bit of a discussion about the connection between the deepSeq function, and Control.Parallel.Strategies.rnf

  • Type level functions. Oleg Kiselyov described how to use type level programming to create a type of constrained lists.

  • Extending the core libraries. Josef Svenningsson started a largish thread on adding a concat.intersperse function to the base library, leading to an interesting discussion on whether the time has come for an formal process for extending core libraries.

  • data Void. Conor McBride proposed adding the type with no inhabitants other than _|_ to the core libraries.

Blog noise

Haskell news from the blogosphere.

About the Haskell Weekly News

Each week, new editions are posted to the Haskell mailing list as well as to the Haskell Sequence and Planet Haskell. RSS is also available, and headlines appear on haskell.org.

The Haskell Weekly News is also available in Spanish translation.

To help create new editions of this newsletter, please see the contributing information. Send stories to dons at cse.unsw.edu.au. The darcs repository is available at darcs get http://www.cse.unsw.edu.au/~dons/code/hwn

Haskell Weekly News: October 19, 2006

Submitted by dons on Thu, 10/19/2006 - 2:15am.

Welcome to issue 45 of HWN, a weekly newsletter covering developments in the Haskell community.

A big week, with a swag of new releases, including the long awaited GHC 6.6.

Announcements

  • GHC version 6.6. The GHC Team announced a new release of GHC! There have been many changes since the 6.4.2 release. For details, see the release notes. Binary builds, source and packages are all found at GHC's home.

  • Haddock version 0.8. Simon Marlow announced Haddock 0.8, including: cabalisation, Hoogle support, image inclusion. Read more.

  • Pugs 6.2.13 released. Audrey Tang announced that after nearly four months of development and 3400+ commits, Pugs 6.2.13, the leading Perl6 implementation written in Haskell, is now available.

  • STM invariants and exceptions. Tim Harris announced that new transactional memory features have been committed to GHC. The main change is to add support for dynamically checked data invariants of the kind described in this paper (pdf). There are two operations: always X :: STM Bool -> STM () and alwaysSucceeds X :: STM a -> STM (). More details in here (pdf).

  • Cabal version 1.1.6 is now available. Duncan Coutts announced that Cabal, the common architecture for building applications and libraries, version 1.1.6 is now available. It is included in GHC version 6.6.

  • Fun in the Afternoon: Thurs 16th Nov in Oxford. Jeremy Gibbons announced that he, Graham Hutton and Conor McBride at Nottingham are organizing a seminar, Fun in the Afternoon, on functional programming and related topics. The idea is to have a small number of talks as an antidote to mid-term blues, three afternoons a year. The hope is that talks will be informal and fun, and that there will be plenty of scope for discussion and chat as well. Looks fun!

  • HC&A Call for Contributions. Andres Loeh asked for contributions towards the 11th Haskell Communities & Activities Report, a bi-annual overview of the state of Haskell as well as Haskell-related projects of all flavours.

  • Generic Haskell version 1.60 (Diamond). Utrecht's Generic Haskell Team announced a new release of Generic Haskell, an extension of Haskell that facilitates generic programming. Generic Haskell includes: type-indexed values and type-indexed types. The Generic Haskell compiler takes Generic Haskell source and produces Haskell code. This release adds support for Generic Views.

  • Streams 0.1 available for GHC 6.6. Bulat Ziganshin announced that the Streams 0.1 library is now compatible GHC 6.6.

Haskell'

This section covers the Haskell' standardisation process.

Discussion

  • GADT terminology. Oleg Kiselyov argued that the term GADT should be reserved for truly generalised algebraic data types, and not just normal data types written in GADT syntax.

  • Extended functionality for record field accessors. Henning Thielemann proposed some record system extensions.

Jobs

Blog noise

Haskell news from the blogosphere.

Quotes of the Week

  • M. David Peterson : With the help of our friendly local ex-professors and Haskell geeks Dr. Meijer and Dr. Lämmel, I have learned to stop worrying and love monad comprehensions
  • SamB: O(n^2) is better than O(hair-gone)
  • chessguy: I didn't think Pennsylvania had anybody cool enough to know Haskell in it
  • int-e: What, unsafeCoerce# is kind-preserving? How boring!
  • lennart: Floating point numbers are terrible. I maintain that before using them people should have an floating point drivers license
  • xerox: #haskell is a good code optimizer.
  • sigfpe: Haskell is so strict about type safety that randomly generated snippets of code that successfully typecheck are likely to do something useful, even if you've no idea what that useful thing is.

About the Haskell Weekly News

Each week, new editions are posted to the Haskell mailing list as well as to the Haskell Sequence and Planet Haskell. RSS is also available, and headlines appear on haskell.org.

The Haskell Weekly News is also available in Spanish translation.

To help create new editions of this newsletter, please see the contributing information. Send stories to dons at cse.unsw.edu.au. The darcs repository is available at darcs get http://www.cse.unsw.edu.au/~dons/code/hwn

Haskell Weekly News: October 10, 2006

Submitted by dons on Mon, 10/09/2006 - 8:38pm.

Welcome to issue 44 of HWN, a weekly newsletter covering developments in the Haskell community.

Developments this week include Lennart Kolmodin's new inotify bindings for Haskell, work begins on Spanish translations of Haskell literature, and new versions of Darcs and Cabal are tagged

Announcements

  • hinotify 0.1. Lennart Kolmodin announced hinotify 0.1, a library to inotify which has been part of the Linux kernel since 2.6.13. inotify provides file system event notification, simply add a watcher to a file or directory and get an event when it is accessed or modified. API and source.

  • Monad Transformer Tutorial. Martin Grabmueller published a small tutorial on using monad transformers. In contrast to others approaches, it concentrates on using them, not on their implementation. PDF and Literate Haskell source available.

  • Speaking Haskell in Spanish. Luis Araujo announced a project to make Haskell documentation more available to Spanish speakers. The idea is to collect information in Spanish about Haskell, including news and tutorials, and to translate Haskell wiki pages.

  • Haskell Packages 6.6. Isaac Jones announced that the Cabal package tools for Haskell are in a good state, with almost 30 packages already in the database. Time to start testing packages, starting with the cabal release candidate that'll go into GHC 6.6, to make sure they work nicely together!

  • Cabal-1.1.6 release candidate. Duncan Coutts released a tarball for the next 1.16 Cabal release candidate. Let's get this tested before GHC 6.6 arrives!

  • Darcs 1.0.9 release candidate. Tommy Pettersson announced the first release candidate for next stable darcs, 1.0.9rc1. This will mainly be a bug fix version to get things right that got wrong or didn't get right in 1.0.7 and 1.0.8, but there are some new features and optimizations too.

  • Haskell and Vim. Marc Weber wrote some Vim scripts to ease various Haskell coding tasks in Vim.

Haskell'

This section covers the Haskell' standardisation process.

Discussion

  • Allowing both prefix unary minus and right section subtraction. Michael Shulman described a technique for writing operators that can be used both as infix or postfix operators, using the new postfix support in GHC 6.6.

  • Google Summer of Code Summit and Haskell. Don Stewart sought feedback on this year's Google Summer of Code Haskell projects, in preparation for Haskell.org's attendance at the Google SoC Summit.

  • GHC under Wine. Robert Marlow described his experience setting up GHC under Wine to produce Windows binaries from Linux.

  • Function lists and arguments. Joel Koerwer described a puzzle to try to apply a function of type a function of type (a -> a -> ... -> a -> a), to a list of arguments of the same length. Some solutions were suggested.

Conference roundup

Jobs

  • Open assistant professorship at Utrecht. Doaitse Swierstra announced a 5 year position for an assistant professor at Utrecht. Current areas of interest include: domain specific embedded languages, programming language design and implementation, generic programming, program verification, advanced type systems. More info.

  • PhD studentship. Shengchao Qin announced that applications are invited for a PhD student to work on resource analysis and verification for dependable embedded software, at the University of Durham. The successful applicant should have a good background in program analysis, type systems and type theory, software verification and embedded systems.

  • Post-doctoral position. Stephan Merz announced that applications are invited for a post-doctoral fellowship on the modeling and verification of domain-specific languages in the MOSEL team at LORIA. The project aims to model domain-specific languages in the specification language TLA+ and to develop verification techniques for programs written in DSLs against high-level correctness properties. Candidates must hold a PhD and should have demonstrated research interest in formal methods and formal reasoning. They should preferably have experience with interactive proof assistants.

Blog noise

Haskell news from the blogosphere.

Quotes of the Week

  • Larry Wall: Perl is turning into Haskell. Someone shoot me.
  • Tim Berners-Lee [and the w3c]: Functional languages such as Haskell ... facilitate the creation of programs that may be easier to analyze than their imperative equivalents.
  • lispy: > init . map snd . filter fst . zip (fix ([True, False] ++)) . ap (zipWith (+)) tail . map length . group . fix $ show
  • lambdabot: [2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,...
  • Verity Stob: Lisp is still #1 for key algorithmic techniques such as recursion and condescension.
  • dcoutts: (:[]) looks like a monster
  • largos: [on programming languages] ...and I'd rather not own as much rope as c/c++ gives you.
  • ozone: When will bytestring be O(1) for all operations?
  • skew: [Monads are] just like the sequences of statements in other languages. Except very rarely have they thought so deeply about what that sequencing means

Code Watch

  • Stand-alone deriving declarations added. bringert. Add support for stand-alone 'deriving' declarations. The main motivation for this is to allow you to use the instance deriving mechanism for data types and newtypes declared in other modules, for example if you want to use generics with existing code that does not derive Typeable and Data, or want to use Show for debugging. The syntax is: deriving Class for Type, and for multi-parameter type classes:: deriving (Class t1 ... tn) for Type

About the Haskell Weekly News

Each week, new editions are posted to the Haskell mailing list as well as to the Haskell Sequence and Planet Haskell. RSS is also available, and headlines appear on haskell.org.

To help create new editions of this newsletter, please see the contributing information. Send stories to dons at cse.unsw.edu.au. The darcs repository is available at darcs get http://www.cse.unsw.edu.au/~dons/code/hwn

Haskell Weekly News: October 03, 2006

Submitted by dons on Tue, 10/03/2006 - 2:04am.

Welcome to issue 43 of HWN, a weekly newsletter covering developments in the Haskell community.

The proceedings of the first Haskell Workshop are now available online, and work has begun on a unified library for generics in Haskell.

Announcements

  • Proceedings Haskell Workshop 1995. Henrik Nilsson announced that in celebration of the 10th Haskell Workshop that took place recently, the proceedings of the very first Haskell workshop, in La Jolla 1995, have now been made available on the Haskell Workshop home page. Thanks to Paul Hudak for help locating the proceedings and arranging for them to be scanned into PDF.

  • Common library for generic programming. Johan Jeuring and Andres Loeh announced an initiative to design a common library for generic programming, which should work together with most of the Haskell compilers, and for which they hope to guarantee support for generics in Haskell into the future. If you want to get involved (or just want to see the discussion), you can subscribe to the generics mailing list. Check the Haskell research wiki for some background on generics.

  • GHC 6.6 Second Release Candidate. Ian Lynagh announced that the Second Release Candidate phase for GHC 6.6 is underway. Get testing!

  • Lazy functional language for the JVM. Luke Evans announced that the research group at Business Objects has developed a lazily evaluated, strongly-typed language called CAL, with many similarities to Haskell, targeting the JVM, to facilitate representing certain kinds of business logic as reusable, composable pieces.

Haskell'

This section covers the Haskell' standardisation process.

Discussion

  • Typeclass versus Prolog programming. Oleg Kiselyov wrote further on the connection between typeclass hacking and logic programming.

  • Irrefutable patterns for existential types. Several Haskellers discussed, in a long thread, issues relating to irrefutable patterns when combined with existentials or GADTs. Read more.

  • GHC on the Mac. Simon Peyton-Jones sought contributors to help maintain GHC on the Mac.

  • Smallest Double. Tamas Papp initiated a thread regarding finding the smallest Double such that 1+x /= x, for a numerics problem.

  • Migrating content to the new wiki. Ian Lynagh forced an action to finally close down the old hawiki, and move all content to the new haskell wiki. Work to be done is here.

Blog noise

Haskell news from the blogosphere.

Quotes of the Week

  • Bill Wood: It became obvious that when a Prolog program is tuned by removing non-determinism it moves towards a functional program.
  • Bjarne Stroustrup: Any verbose and tedious solution is error-prone because programmers get bored. [S 9.4 of C++, 2nd edition]
  • Hamilton Richards: It's fair to say that functional programming requires a very different mind-set, but once you've mad e the `jump`, programming in conventional languages feels like doing arithmetic in Roman numerals.
  • Larry Wall: Take Lisp, you know it's the most beautiful language in the world -- at least up until Haskell came along.
  • dons: Welcome to computer science, we count from 0.
  • glguy: This is like Web 5GL. I like it!
  • sjanssen: Quoth the Prelude, Chapter 6, verse 4: Yeah verily shall repeat floweth cons cells over.

Code Watch

  • Fri Sep 29 09:07:17 PDT 2006 simonpj. Remove Linear Implicit Parameters, and all their works. Linear implicit parameters have been in GHC quite a while, but we decided they were a mis-feature and scheduled them for removal. This patch does the job.

About the Haskell Weekly News

Each week, new editions are posted to the Haskell mailing list as well as to the Haskell Sequence and Planet Haskell. RSS is also available, and headlines appear on haskell.org.

To help create new editions of this newsletter, please see the contributing information. Send stories to dons at cse.unsw.edu.au. The darcs repository is available at darcs get http://www.cse.unsw.edu.au/~dons/code/hwn

Haskell Weekly News: September 27, 2006

Submitted by dons on Wed, 09/27/2006 - 12:42am.

Welcome to issue 42 of HWN, a weekly newsletter covering developments in the Haskell community. Each week, new editions are posted to the Haskell mailing list as well as to the Haskell Sequence and Planet Haskell. RSS is also available, and headlines appear on haskell.org.

This week we see a new Hugs release, and the results of the ICFP contest are out! We feature a special report on the Commercial Users of Functional Programming workshop, courtesy of John Hughes

Announcements

  • ICFP Contest Results. CMU's Principles of Programming Group announced the results of this year's ICFP programming contest. Congratulations to the winning team from Google, 'Team Smartass', (Christopher Hendrie, Derek Kisman, Ambrose Feinstein and Daniel Wright), who used Haskell along with C++, Bash and Python. Haskell has now been used by the winning team three years running! An honourable mention to team Lazy Bottoms, another Haskell team, who managed to crack several of the puzzles first. Five teams from the #haskell IRC channel were placed in the top 50. A video stream of the results announcement is available, shot and cut by Malcolm Wallace. Many thanks to the CMU team for organising such a great contest!

  • New release of Hugs. Ross Paterson announced a new minor release of Hugs, fixing a few bugs with the May 2006 release, and with libraries roughly matching the forthcoming GHC 6.6 release. It is available from the Hugs page.

  • HAppS version 0.8.2. Einar Karttunen announced the release of the Haskell Application Server version 0.8.2. HAppS is a Haskell web application server for building industrial strength internet applications safely, quickly, and easily. With HAppS you focus entirely on application functionality implemented in your favourite language and you don't have to worry about making sure all sorts of server subsystems are functioning properly. More info.

  • Codec.Compression.GZip and .BZip. Duncan Coutts released two new packages: zlib and bzlib, which provide functions for compression and decompression in the gzip and bzip2 formats, directly on ByteStrings. Both provide pure functions on streams of data represented by lazy ByteStrings. This makes it easy to use either in memory or with disk or network IO. There is API documentation is available here and here.

  • System Fc branch merged into GHC. Manuel Chakravarty merged the System Fc branch of GHC into GHC head. This is a significant development, adding extensions to GHC to support an FC-based intermediate language, a new implementation of GADTs, along with indexed data types and indexed newtypes (generalised associated data types). More details about the implementation.

  • Job writing security software in Haskell. Andrew Pimlott announced that Planning Systems, Inc. has a job opportunity for Haskell programmers, writing a high-assurance authorization system. Job description.

  • Dr Haskell 0.1. Neil Mitchell released Dr Haskell, a tool to help suggest improvements to your Haskell code. Dr Haskell will analyse your code, and suggest shorter alternatives for rewriting. More details.

  • BitSyntax for Haskell. Adam Langley released a bit syntax library for Haskell, based on Erlang's bit syntax (great for building and breaking up binary structures). Nice!

  • File fuzzing. Tim Newsham made available FileH, a Haskell tool for generating test data via random file mutation. More details.

  • A DSL for state machines. Stephane Bortzmeyer announced a Haskell implementation of a proposal to the IETF to standardize a language used for finite state machines (which are common in IETF standards). The reference implementation is available.

  • A language tag parser. Stephane Bortzmeyer announced GaBuZoMeu, a set of programs to parse and check language tags (see RFC 4646 produced by the IETF Working Group LTRU - Language Tag Registry Update).

Haskell'

This section covers the Haskell' standardisation process.

Conference roundup

The Commercial Users of Functional Programming workshop (CUFP), held in association with ICFP, attracted a record turn-out this year. 57 attendees came to listen to 9 speakers talk about commercial uses of Scheme, Erlang, Reflect, OCaml, and Haskell. Four of the speakers talked about applications of Haskell.
  • Linspire in Haskell. Clifford Beshers talked about the adoption of Haskell at Linspire. Linspire switched recently from OCaml to Haskell, citing readability, classes, the IO monad, and more complete libraries as reasons. So far CGI scripts and a package autobuilder have been implemented in Haskell. Static typing, and the use of purely functional data structures on disk, have helped make for reliable code. Performance has been generally good, although Parsec parsers proved to be slow on larger files--a problem that was solved using Data.ByteString. Space leaks have not been a problem, perhaps because frequent IO keeps programs strict. Belying the myth that functional programmers are hard to recruit, Linspire's announcement that they were adopting Haskell generated several resumes, despite explicitly stating that they were not recruiting.

  • Haskell programming at Credit Suisse. Howard Mansell talked about Haskell programming at Credit Suisse in New York. This group's business is derivative trading for clients. Valuing complex derivatives is computationally costly, requiring nightly runs on thousands of CPUs. There is a real competitive advantage in being able to build models quickly, since some exotic derivatives may only be traded 10-100 times in total. Previously models were built using Excel, with heavy computations delegated to C++ plugins. Most of the Excel code has now been replaced by Haskell, with Excel just providing the user interface (which in turn is generated by DSELs). The work has been done by Lennart Augustsson and Gabriele Keller, but Credit Suisse needs more Haskell programmers -- they're hiring.

  • Hardware design at Bluespec Inc.. Rishiyur Nikhil talked about Bluespec Inc, which offers System Verilog tools implemented in about 90K loc of Haskell. Bluespec's tools are based on MIT research in the 90s into generating hardware from term rewriting systems; using Bluespec's 'rules' complex hardware can be described at a high level, improving productivity and reducing errors. Selling the tools based on Haskell requires short, punchy examples to convince old hands that there is a better way than writing RTL by hand. Bluespec have started sales, and many more trials are under way.

  • Aetion, AI and Haskell. Garret Morris talked about Haskell applications at Aetion, which is a defence contractor offering AI applications based on Bayesian nets. Rapidly changing priorities make it important to minimize the code impact of changes, which suits Haskell well. Aetion have developed three main projects in Haskell, all successful. Haskell's concise code was perhaps most important for rewriting: it made it practicable to throw away old code occasionally. DSELs allowed the AI to be specified very declaratively. Less successful was the decision to link Haskell to a GUI in Java: the need to serialize data made it impossible to use functions as representations, which was unfortunate. Other issues included getting libraries to work together, patchy Windows support, and a need for more debugging tools.

Discussion

  • Curious Functor class. Ashley Yakeley described the curious class of functors for which foralls can move across.

  • Variadic functions and typeCast. Michael Shulman submitted a general version of the trick to implement variadic functions in Haskell outlined by Oleg

  • Serialising existential types. Misha Aizatulin pondered the interesting problem of serialisation of datatypes with existential constructors. Several options were suggested.

  • Replacing GMP. Peter Tanski updated the page relating to portably replacing GMP in GHC (and other Haskell systems)

Blog noise

Haskell news from the blogosphere.

Quotes of the Week

  • Clifford Beshers : "When we code in Haskell, we go home on time"
  • Bulat : "There is new Time library, which is supposed to replace old System.Time. We hope that it will happen before 2038"
  • edwardk : "I should probably just type up the problem specification in Haskell and click compile. Funny how that seems to yield the answer"
  • vincenz : "OCaml used to be pretty, Haskell made it ugly"
  • glguy : "I remember what class I was in when I was reading Hudak's book and discovered `fix'. Life altering..."
  • glguy : "> take 10 $ map length $ fix (([()]:).scanl (++) [()])"
  • lambdabot :"[1,1,2,3,5,8,13,21,34,55]"
  • agentzh : "Haskell is really a powerful weapon"
  • gaal : "You know you've been reading lots of Haskell papers when... someone says '(bbiab, $job)' and you try mentally to run :t on that"
  • audreyt : "Pugs seems to be just my excuse to apply each and every technique from the GHC changelogs..."
  • Pseudonym : "[OlegFacts] Oleg solves N P-hard problems in N log N time... in the type system"
  • dons : "[On improving Cabal dependency handling] fps 0.8 is an exemplary instance of part number fps 0.8. Interestingly, this one is lavender. Also, it is broken: it is (a fps 0.8 missing a base 1.0)."
  • Mark Bessey : "When really massively-parallel systems start to become more common, the programming model will have to change. What languages you'll likely use to program these beasts is an interesting question - most likely, it'll be a functional language, something like Haskell, or Erlang."
  • Philippa : "[vincenz] Forget theory, it's about pragmatics [Philippa] we're talking FP, they tend to be the same thing"

Contributing to HWN

To help create new editions of this newsletter, please see the contributing information. Send stories to dons at cse.unsw.edu.au . The darcs repository is available at darcs get http://www.cse.unsw.edu.au/~dons/code/hwn