Status

Ongoing tasks (September 2013)

Hackage 2

The IHG
members have funded the effort to get Hackage 2 up to feature parity
and get it ready for the switchover. The IHG funded this effort because
while the volunteer effort got us the "first 90%" of the way there,
including a number of new features, there was still the "last 90%" to
do to get it production ready.

The IHG members decided to fund Hackage 2 not just because they are
good citizens, but out of enlightened self-interest. Hackage has over
5000 packages written by over 1000 people – including the world's best
Haskell developers. This is a massive resource. The IHG members
recognise that improvements to the tools and infrastructure that the
community uses helps the community to produce more and better code.
This is in the interest of everyone in the community, including the
Well-Typed and the Industrial Haskell Group (IHG) are very pleased to
announce that Hackage 2 is now available for public beta testing. The
plan is to do the final switchover in late September, to coincide
with ICFP.

Completed tasks

Current versions of cabal-install (since version 0.14.0)
make use of a completely rewritten dependency solver.
The new solver is generally faster and more configurable. In particular, it is able to
make use of backtracking, and it employs heuristics to find a satisfactory install plan
in more scenarios. The changes made to the dependency solver will probably enable us to
tackle some long-standing enhancement requests for 'cabal-install'.

Some parts of the
design of the new dependency solver are described in a Haskell Implementors Workshop
talk by Andres (slides).

Haskell offers two types for integers: 'Int' which is bounded and can overflow,
and 'Integer' which is unbounded. The 'safeint' library offers a third option:
bounded integers that will not overflow, but rather throw an exception once an
operation would cause an overflow. Such an exception can then be handled normally
in the program.

The first prototype of the library is
available on Hackage.
It not as efficient as it
could possibly be, but the plan is to use overflow-checking assembly instructions
in a future version. Even in its current version, performance of the safe integer
type should be between the 'Int' and 'Integer' types, therefore offering a safer
alternative for scenarios where 'Integer' is too slow.

Dynamic libraries, also known as shared libraries, are one of the main mechanisms use to
integrate systems. Making it possible for GHC to generate shared
libraries makes it possible to plug Haskell code into existing systems.

It was already possible to make DLLs on Windows however each one is
monolithic and links in the entire runtime system and base libraries.
This ongoing work is to bring the same level of support to Windows as now
exists on Linux. In particular the goal is to allow each Haskell package
to be built as a separate DLL and to allow several Haskell DLLs in the
same process to share a single instance of the runtime system.

Most of the infrastructure for this project is ready, but still requires
some work on integration and testing. The project is likely to be continued
in the future.

GHC uses the GMP library to implement Haskell's arbitrary precision
'Integer' type. The GMP library is licensed under the LGPL. It is now
possible to change the implementation of GHC's integer library, for
example to use a pure Haskell implementation.

The Cabal package format allows multiple components within a single
package, such as a library and an executable. Previously modules used
by multiple components would be built multiple times (since potentially
they may use different compilation flags). It is now possible to specify
that an executable depends on the library within the same package and
thus share the compilation. For big projects this can significantly cut
build times.

CUFP presentation

The presentation looks at the motivation leading to the formation of the
IHG, how it has worked so far and what lessons we can learn. It also looks
at how we can encourage the positive feedback cycle between commercial
users and the wider community.