Category Archives: Weekly News

Weekly News

Another build of ghc 7.8 available

Yesterday evening I pushed out a new build of ghc 7.8 to [haskell-testing] and now all packages and the DB are signed so the stanza to use is


[haskell-testing]
Server = http://xsounds.org/~haskell/testing/$arch

Please make sure to put it right after [main] to pacman doesn’t accidentally mix in Haskell packages from [extra] or [contrib].

Enjoy!

Arch Haskell under new management :-)

Recently there’s been quite a few things happening in the Arch Haskell community. Since Don stepped down from Arch Haskell work there have been quite a few changes in the community.

Before describing those changes I feel it’s worth pointing out just what Don has done over the last year or so. Pretty much single-handedly he has made sure that ArchLinux has almost all of Hackage available as native (source) packages. That resulted in ArchLinux being one of the best, if not the best, Linux distro for Haskell developers. In the end he maintained 1937 packages on AUR (there are currently 25237 packages on AUR in total), and he also wrote and maintained the tool used to track Hackage (cabal2arch).

So, what have we been up to since Don’s announcement?

First of all we’ve moved the activity to github. This allows us to maintain the packages as a team rather than put the entire burden on a single person. The source repositories, cabal2arch, archlinux, and archlinux-web are obviously where the source for the tool and its dependencies are kept. Furthermore there’s the habs git repo. This repo contains the source for all the packages (PKGBUILD and *.install files). Keeping all source packages on github will allow us to more easily accept updates and fixes to individual packages from people in the community. Unfortunately uploading to AUR still remains a bottle neck. Which conveniently brings me on to the ideas for the future.

Even though there now are two people who can upload packages AUR as arch-haskell, it is still likely to be a pain point in keeping up with the uploads to Hackage. The long-term solution is to stop using AUR, but for that to be possible we need to have some tool support for downloading and compiling packages from archhaskell/habs. Until that tool support is there we’ll keep uploading to AUR.

In the future we would also like to provide a subset of the packages in binary form. The main issue at the moment is keeping on top of the re-building that is necessary (if package foo is updated then all its dependants need to be re-built too). We are however well on our way towards having tools to support that. The next big issue is where to house the binary packages :-)

Even further into the future we will look closer at whether a repo of source packages really is the most effective way to track Hackage.

Even though we now have a few people who are hacking away on the tools, and try to keep up with Hackage, we can always use more help. So if you are interested in helping out this is a great opportunity to make a large impact. Just in this post I’ve mentioned a few areas where we need help:

  • Run cabal2arch on new packages on Hackage, QA the results and then file pull requests against archhaskell/habs.
  • Getting tools that support downloading from archhaskell/habs so we can move off AUR.
  • Improving the tools used to build binary packages.
  • Improve cabal2arch.
  • Anything else you can think of.
  • Last but not least, if you know a place where we could house binary packages, please let us know.

So, I encourage everyone with an interest in Haskell on ArchLinux to join the mailing list and get involved. No prior experience with Haskell is really necessary, a bit of shell (bash) scripting is enough for some of the planned things.

See you on the list!

berp: an implementation of Python 3, now in AUR (compiler and interpreter)

berp, is an implementation of Python 3, written in Haskell. It is now available in AUR.

It provides a compiler and an interpreter. In both cases the input Python program is translated into Haskell code. The compiler turns the Haskell code into machine code. The interpreter runs the Haskell code immediately via the GHCi interpreter. The user interface of the interpreter imitates the one provided by CPython.

For more information:

ThreadScope for Haskell now in AUR

ThreadScope is a graphical thread profiler and debugger for Haskell.

The Threadscope program attaches to a running Haskell program, allowing us to debug the parallel performance of Haskell programs. Using Threadscope we can check to see that work is well balanced across the available processors and spot performance issues relating to garbage collection or poor load balancing.

ThreadScope is now available pre-packaged for Arch Linux via AUR. It builds on the newly cabalized GTK libraries, such as haskell-cairo.

For information on how to use ThreadScope to improve the performance of your multicore Haskell programs, see the references:

Regular, shape-polymorphic, parallel arrays now in AUR

Repa, a new library for multi-dimensional automatically-parallel arrays in Haskell, is now available in Arch Linux via AUR.  Such arrays may be converted to and from bytestrings, and written out in various formats. Example algorithms are available, including fft2d, matmult, and laplace, along with an algorithm library. The library may prove useful for scientific and numerical computing, where high level languages, with good parallel performance, should shine.

More information about Repa is available:

The full set of packages are available in AUR:

Grammatical Framework, a programming language for multilingual grammar applications, now in Arch

GF, a programming language for multilingual grammar applications is
http://aur.archlinux.org/packages.php?ID=39561.

GF provides many tools for multi-language programming, and can be considered:

  • special-purpose language for grammars, like YACC, Bison, Happy, BNFC, but not restricted to programming languages
  • functional language, like Haskell, Lisp, OCaml, Scheme, SML, but specialized to grammar writing
  • natural language processing framework, like LKB, XLE, Regulus, but based on functional programming and type theory
  • categorial grammar formalism, like ACG, CCG, but different and equipped with different tools
  • logical framework, like Agda, Coq, Isabelle, but equipped with concrete syntax in addition to logic

GF can be used for building

GF is written in Haskell.

Arch Haskell News: February 2010

Hackage now has 1851 Haskell packages, of which 1541 (84%) have been natively packaged for Arch in AUR. All these packages are available via AUR, using the “bauerbill” tool (or other full-resolving package tool for Arch).

You can find the status of all Haskell packages in Arch here, regularly updated using the archlinux Haskell package tools.

Since the GHC 6.12 upgrade, there have been some major package updates:

Most things are now ready for GHC 6.12, with the notable exception of packages that:

  • depend on gtk2hs (not yet released for GHC 6.12)
  • parsec < 3 (Arch will be downgrading to parsec 2 to be HP compliant).

Arch Linux Updates to GHC 6.12

We’ve (mostly) completed the major upgrade of Haskell packages on Arch Linux to use GHC 6.12. The summary:

  • We updated to GHC 6.12
  • Most things are working.
  • You can’t use “yaourt” any more — it is broken on Haskell dependencies.

There are several consequences of this upgrade for Arch Haskell users, so read on for the full stories.

Changes to GHC

Firstly, GHC has been improved in many ways:

  • Parallel execution performance is better (for your multicore Haskell apps)
  • Dynamic linking of Haskell libraries is supported (see this tutorial).
  • Package management is far more robust and scalable (you’ll see improvements in install times if you use many packages).
  • And of course, many tweaks and new features in the language and base libraries.

To upgrade we recommend you completely clean your existing Haskell Arch packages, via:

sudo pacman -c –remove ghc

to do a recursive removal of all packages, then install ghc in a clean state:

sudo pacman -S ghc

Changes to Extra / Community Packages

With the GHC 6.12 update, GHC no longer distributes a number of libraries that it used to, including:

All these packages are now in the (Extra) repository, and make up the bulk of the support for the Haskell platform in (Extra). You can find them with pacman.

Major Applications: xmonad, darcs, …

The major applications have all been updated, and you should have no trouble upgrading to the versions in (Extra) and (Community).

For example, xmonad:

  1. upgrade ghc with pacman
  2. install xmonad and xmonad-contrib with pacman

and you’ll be good to go.

“Provides” packages: Do not use Yaourt!

A consequence of moving these packages out of the ghc package is that almost all Haskell packages had missing dependencies. Previously, if a Haskell package had used say, transactional memory, it only had to depend on “ghc” in its specification. That is no longer the case, and to solve this problem of dependencies moving around once and for all we have enacted the following policy for Haskell packages:

We have updated all packages in AUR to list explicit dependencies. So now you will see things like this, for the latest haddock.

  • Dependencies: haskell-array haskell-cabal haskell-containers haskell-directory …

So even the libraries distributed with GHC are explicitly listed. This has major consequences for which package builder tool you use!

To build Haskell libraries and programs, the package tool must support the “provides” field. yaourt does NOT support “provides. You need to use a different package tool

We’ve put together a list of preferred package tools here, and I (dons) have switched to bauerbill, which is fast, and has full support for more complicated package specifications. You use it exactly as for yaourt, but without the bugs:

     sudo bauerbill --no-color --aur -S haskell-csv

The Haskell packaging tool for Arch, cabal2arch, has been fully updated to support the new “provides” policy, and in turn has been used to update all 1500+ Haskell packages in AUR.

If you have any dependency resolution problems, make sure you are not using yaourt.

Version changes

We’re moving towards full support of the next Haskell Platform release in binary form from (Extra). To get there we decided to upgrade to QuickCheck 2. This means that some packages that haven’t yet migrated to QuickCheck 2 will be temporarily unavailable from AUR (including HDBC).

gkt2hs and wxHaskell are also not yet supporting GHC 6.12. They upstream maintainers are aware, and these packages will be updated once upstream is ready.

AUR Packages

AUR now carries 1500+ Haskell packages, and all have been updated to the new provides syntax. You can track the last known build/version status of these packages here.

Get in touch!

You can join in the community for Haskell users on Arch, via:

wxHaskell packaged for Arch

wxHaskell, the venerable portable and native GUI library for Haskell, is now packaged for Arch, in the following packages:

Which you can install with yaourt:

  yaourt –aur -S haskell-wxcore haskell-wx

And is already used by a number of graphical Haskell programs and libraries:

all packaged.

happstack 0.4: A scalable framework for developing web applications in Haskell

Happstack is the Haskell Application Server Stack. It is a scalable framework for developing web applications, similar in purpose to Django, RoR, Turbogears, Grails, Seaside. happstack powers patch-tag.com and gitit.net and you can use it to beat the Arc Challenge. The latest release of happstack is now available in Arch, via AUR, and features a built-in HTTP server, built-in persistant data store, many ways to do templating, a rich EDSL for designing requests and responses, and easy integration with an external database, or webserver.

All the packages are here:

To get started with happstack, you can work through Real World Happstack.