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

Win64 port of GHC
We have ported GHC to work on Win64.

From version 7.6.1 of GHC on, 64-bit Windows is a supported platform.

A new dependency solver for cabal-install
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).

A library for safe integers
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 on Linux
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.

This feature is available in GHC since version 6.12.1.

Ongoing work for dynamic libraries on Windows
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.

Allow building GHC without the GMP library
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 'integer-simple' library is part of GHC since version 6.12.1. Using this library requires a special build of GHC.

Cabal improvement to reduce build times
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.

This feature is included with Cabal since version 1.8.0.2.

CUFP presentation

Duncan presented a talk at CUFP on the birth of the Industrial Haskell Group.

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.

Copyright © 2009–2014, Industrial Haskell Group <info@industry.haskell.org>