Difference between revisions of "ZuriHac2014/Projects"

From HaskellWiki
Jump to: navigation, search
(The `psqueues` package)
(LGtk: GUI framework in Haskell)
Line 102: Line 102:
* Péter Diviánszky
* Péter Diviánszky
* Pék Dániel
= LambdaCube 3D - Stunts game=
= LambdaCube 3D - Stunts game=

Revision as of 17:31, 4 June 2014

These are some of the projects that ZuriHac 2014 attendees will be working on:


See: http://hackage.haskell.org/package/aeson

  • Bas van Dijk (Faster JSON encoder)

Scion / Lambdachine

  • Thomas Schilling


See: http://jaspervdj.be/hakyll/

  • Jasper van der Jeugt
  • David Wagner

Haskell: the Gathering

Implementation of Magic: the Gathering in Haskell. We will work on the rules engine, card implementations (both in Haskell) and the web client (TypeScript/HTML). Help is welcome in all three areas.

  • Martijn van Steenbergen


Persistent implementation of the T-Digest (https://github.com/tdunning/t-digest) quantile estimation data structure, for use in ekg.

  • Johan Tibell


Nomyx is a game where you can change the rules while playing: http://www.nomyx.net

  • Corentin Dupont (I'll work on new features and bugs . Help/advices are welcome :))


See: http://snapframework.com/

  • Alfredo Di Napoli - I have in mind a couple of interesting features I would like to see in snap.


See: http://hackage.haskell.org/

  • Ian Ross (tags interface)
  • Alp Mestanogullari (most likely a nice statistics page)

GHC bug squashing

I plan to fix a few random GHC bugs and I’m more than happy to guide GHC-newbies in doing the same. Planning and coordination will happen at https://ghc.haskell.org/trac/ghc/wiki/ZuriHac2014. I started to collect some suitable tickets, feel free to add some.

  • Joachim Breitner
  • Lorenzo Tabacchini


See: http://github.com/gseitz/oauth-provider

  • Gerolf Seitz (I would like to have a RFC / code-review on oauth-provider)

Math Symbols in Diagrams

I'd like to be able to label diagrams with mats symbols and fonts: http://projects.haskell.org/diagrams/. There has been some discussion of this on #diagrams and I need to write up an approach. NB I have used diagrams a lot but never hacked on the package itself.

  • Dominic Steinitz
  • David Wagner


See: http://hackage.haskell.org/package/propellor

  • David Wagner (I would like to add monit support to propellor).


We have recently open sourced our rest framework which Erik Hesselink gave a presentation about at last years ZuriHac. It provides a declarative way to define REST resources (rest-core) which can be used to run the api on different web servers (rest-happstack, rest-snap) and to automatically generate clients for different languages along with documentation and usage examples (rest-gen). We want to write introductory materials to get people started. We'd appreciate help and we'd be happy to sit down with anyone wanting to get started with rest.

  • Adam Bergmark
  • Erik Hesselink
  • Sebastiaan Visser

Project ideas:

  • Write tutorials based on the rest-example blog application
  • Refactor the rest-gen haskell client generation to use haskell-src-exts
  • Write a test-framework that runs an api and uses its generated client

Erlang Interpreter in Haskell

This is my learning project for Haskell, and since I come from Erlang background I have chosen to combine both things into one.

  • Gleb Peregud
  • Felipe Zapata

LGtk: GUI framework in Haskell

See http://lgtk.wordpress.com/ and http://www.haskell.org/haskellwiki/LGtk. I would like to work on a browser backend with GHCJS and improving documentation (writing a tutorial especially).

  • Péter Diviánszky
  • Pék Dániel

LambdaCube 3D - Stunts game

LambdaCube 3D is a domain specific language and library that makes it possible to program GPUs in a purely functional style. During ZuriHac I'll implement FRP based menu for Stunts demo. If you are interested in game development join! :)

  • Csaba Hruska


Revise the package's API and prepare the 2.0 version.

WIP is at https://github.com/feuerbach/extensible-effects

  • Roman Cheplyaka


Complexity is a tool to measure the emprical complexity of functions. During Zurihac we want to rewrite complexity so that it makes use of the excellent Criterion package. We also want to rewrite the reporting part. Perhaps not depend on any GUI toolkits but instead generate a static HTML report.

  • Roel van Dijk
  • Tim Schwarte

Binding for librabbitmq

See https://github.com/alanxz/rabbitmq-c

  • Mikael Brockman

The `psqueues` package

Help creating a psqueues package providing performant implementations of priority search queues. These are data structures that manage a set of triples of the form (key, priority, value) and allow efficient lookup by key and efficient lookup and removal of the element with minimal priority. More precisely, I imagine that the package should provide IntPSQs, HashPSQ, and PSQ data structures whose requirements and API are analogous to IntMaps, HashMaps, and general Maps.

The implementation plan is as follows.

  • The APIs are structured analogously to the existing containers and unordered-containers APIs extended with additional functions inspired by the PSQueue package.
  • The implementation of PSQ is based on Hinze's construction and the code already provided in the PSQueue package.
  • The implementation of IntPSQs uses a radix-tree that stores (key, priority, value) triples in inner nodes and enforces the min-heap property. There is a draft of this structure in TODO URL, which significantly outperforms the PSQueue package specialized to Ints (see [1]).
  • The implementation of the HashPSQs uses an IntPSQ over the hash values of the keys and manages the collisions using a PSQ to guarantee logarithmic worst-case performance for inserts and lookups.

The two main use cases of the structures provided by this package are the GHC IO manager and pure LRU caches, which are used in many web application backends to speedup data storage access. However, I'm sure there are more use cases for efficient priority search queues.

There is a branch in my fork of containers that contains a minimal, but working and well-performing IntPSQ. The work that remains to be done is to

  • incorporate and modernize the PSQ from the PSQueues package
  • combine IntPSQs and PSQs to form a HashPSQ
  • implement extensive tests
  • implement more realistic benchmarks for the above two usecases

This project is well-suited for a group of Haskellers starting at intermediate level, as the work can be parallelized well and the individual tasks are small and well-defined.

Project lead: Simon Meier


  • Alex Sayers
  • Jasper Van der Jeugt