View source for MuniHac2016/Projects

''Please add projects (following the template) that you are planning to work on during MuniHac.''

= OpenCV 3.1 Haskell binding =

'''Homepage''': https://github.com/LumiGuide/haskell-opencv

'''Contact''': Bas van Dijk

'''Required skill level''': Expert

haskell-opencv is an in-development opensource Haskell binding to the popular OpenCV-3.1 C++ Computer Vision library. Note that other Haskell OpenCV bindings already exist but these target the older 2.4 version of OpenCV.

The library comes with haddock documentation. Example programs are embedded in the documentation and are automatically build and run as part of the test-suite. They output images which are referenced from the documentation. Besides documentation the library also comes with a test-suite and the beginning of a benchmark suite. Finally, the library is already being used in production by LumiGuide for [https://bicycledutch.wordpress.com/2015/06/09/bicycle-parking-guidance-system-in-utrecht/ detecting available space to park your bicycle or car in big parking facilities].

The library is not finished yet. A lot of functions still need to be bound. However, the basis is there to easily bind missing functionality. All the core pieces are in place: core datatypes like points, sizes,  polygons and most importantly matrices are there. It's also easy to bind missing datatypes. We use inline-c to inline C++ code in our Haskell code. We also have a way of dealing with exceptions originating from C++ code.

The goal of this MuniHac project is simply to bind more functionality. Roel and Bas will be available as mentors and can help you get started quickly and provide advice on how to best represent OpenCV functions in Haskell.


= Servant =
'''Homepage''': https://github.com/haskell-servant

'''Contact''': arianvp, fizruk


== Servant GHCJS ==
'''Required skill level''': Intermediate

''Isssue'': https://github.com/haskell-servant/servant/issues/51

''Branch'': https://github.com/haskell-servant/servant/tree/client-ghcjs

We have a branch with experimental GHCJS support for the latest servant version.
We need to have a good story for running unit tests on GHCJS so that we can check this code is correct.


== Servant-python ==
'''Required skill level''': Intermediate

Servant comes with a library `servant-foreign` that allows us to generate http clients in different languages like javascript and ruby. A servant-python library has been requested a few times, and it would be nice to add this to servant.

You could look at the code in `servant-js` and adapt it to generate python code. Preferably using the python `requests` library.

==  Servant GraphQL ==
'''Required skill level''': Expert

https://github.com/haskell-servant/servant/issues/554

We can look at how we can verify data based on a graphql description.
We could look at the Universe pattern to solve this. (http://2015.ecoop.org/event/curryon-coding-for-types-the-universe-pattern-in-idris)

== Servant Custom Type Errors ==
'''Required skill level''': Intermediate

https://github.com/haskell-servant/servant/issues/576

Servant generates scary error messages when things go wrong. GHC8 introduces custom type error messages. Perhaps you can explore how we can improve the usability of the servant library with this.


arianvp will be available as a mentor for servant-related projects.

= ghc-mod &ndash; Haskell editor integration for Emacs, Vim, Atom etc. =

'''Contact''': Daniel Gröber (GH: DanielG, IRC: dxld), #ghc-mod (freenode)

== ghc-mod-core: aka. "ghc-mod The Good Parts" ==
'''Required skill level''': Intermediate

https://github.com/DanielG/ghc-mod-core

ghc-mod's codebase has been accumulating a lot of functionality over the years,
leading to a significant maintenance burden in keeping everything working. We're
trying to split the essential parts off into a new library and eventually rebase
everything else on top of that.

== ghc-mod: make using different compiler versions across projects easier ==

'''Required skill level''': Expert

https://github.com/DanielG/ghc-mod/issues/615, https://hackage.haskell.org/package/rts-loader#readme

One of the major problems with ghc-mod is the fact that we directly link against
the GHC API library which essentially means we can only support one GHC version
per ghc-mod installation. Since ghc-mod now supports Stack this has become a
much larger problem since GHC version changes are now transparent to users.

There are two approaches to solving this that we're considering: Either we
(re)compile the ghc-mod executable at runtime against the GHC version we detect
the project to be using or we use some dynamic linker voodoo. I've been
prototyping a way to do the latter (see rts-loader package on Hackage) but it's
not clear yet if this is a good idea or not.

= Foundation Haskell =

'''Homepage''': https://github.com/haskell-foundation

'''Contact''': Vincent Hanquez, Nicolas Di Prima, Jan Gerlinger

'''Required skill level''': Beginners to Experts

Foundation is an ambitious community project trying to bring together keys part of modern haskell libraries functionality, and make everything work together better and consistently. The idea is to provide a better base with everything that a modern haskeller need to complete projects.

We're open to contributions and ideas in all differents breadth, for now we're concentrating on:

* the basic core types like strings, arrays, and their APIes.
* Basic system abstraction features like system randomness

= cabal new-build =

'''Homepage''': https://github.com/haskell/cabal

'''Contact''': Duncan Coutts

'''Required skill level''': Intermediate to Expert

The cabal tool (cabal-install package) has some major work going on: we're completely reworking all the internals and the major commands to make everything work a lot better. This is the "nix style local builds" stuff that you may have heard about (e.g. http://blog.ezyang.com/2016/05/announcing-cabal-new-build-nix-style-local-builds/). For getting started using it, see the new user guide http://ezyang.com/nix-local-build.html

There's lots to do, and not all of it is very tricky. In fact there's a lot of simple things to implement that the main folks pushing this effort just havn't got around to yet. For example while there's been a lot of focus on the new improved internal mechanisms there's lots of little things to make the UI experience better that still need to be done. Or there's design work you could help with, especially from a UI point of view, e.g. making sure existing or proposed UI will work for common workflows. Of course if you're keen, there's also bigger things you could get stuck into.

There will be advice and help available from Duncan and from other people on the #hackage IRC channel (on freenode, same IRC network as #haskell).

While this "new-build" stuff is the big project of the moment, it is always welcome to help out with anything related to Cabal or Hackage and we are always very welcoming of new people and new ideas.



= Leksah IDE =
'''Homepage''': https://github.com/leksah/leksah

'''Contact''': Jacco Krijnen

'''IRC''': #leksah (Freenode)

'''Requires Skill Level''' Beginner to expert

Leksah is a dedicated Haskell IDE written in Haskell. There is lots of stuff you can help with.

* Find an open issue on the issue tracker (also note the ones "newcomer" label)
* Document a module
* Try installing and breaking Leksah
* Write some user documentation
* Come up with something new to work on

= Magic: the Gathering =

'''Website''': https://github.com/MedeaMelana/Magic

'''Contact''': Martijn van Steenbergen

'''IRC''': #mtghs (Freenode)

'''Skill level''': beginner - expert

MtG is a fantasy-themed card game. There are lots of [https://www.google.com/#q=magic+the+gathering+introduction introductions online] if you're not familiar yet with the game. To contribute to the project, it helps if you know the rules a bit.

Things that require just beginner Haskell knowledge: contributing individual cards. Here are example Git commits that [https://github.com/MedeaMelana/Magic/commit/82418e51269983894e89d9606ddb47926c608241 adds a simple card], and a [https://github.com/MedeaMelana/Magic/commit/aa9bd92d426c3250ab1bcae82e8b108f11dfcf19 more complicated card].

More advanced things involve adding cards for which a new feature needs to be added to the engine. For example, adding [http://magiccards.info/m13/en/98.html Liliana's Shade] required [https://github.com/MedeaMelana/Magic/commit/b60660674ebb0a9118484e030358f9e3de549e29 adding a Reveal event].

= Haskell integration in Emacs (or $editor) on NixOS =

Right now most Haskell plugins for Emacs rely on tools in your `PATH`.
With nixpkgs you build a custom environment for each project which
also links together a custom `ghc-pkg` environment. These plugins
should therefore use this environment package-local (and build it if
necessary).

I have had some success with searching for project-wide `shell.nix`
and using those, but it’s not very reliable. I would like to improve
that (or talk about alternative solutions).

If you use nix and use a different editor I’d like to talk to you
as well (since the problems are the same).

'''Contact''': Profpatsch

'''Skill level''': Haskell: Any, Nix: Intermediate–, Emacs: basic elisp

= A type-level cellstore-style database backend for document stores =

'''Homepage''': https://github.com/rubenmoor/cellstore

'''Contact''': Ruben Moor

'''Required skill level''': Expert (I could need help for type-level stuff)

Check out the readme for the full description.

I'm working on a database interface for document stores (think MongoDB) with type-safe queries. The idea is to have a database model as a type and have the compiler infer the result type, effectively type-checking your queries.

In addition, the database model is inspired by the idea of a cellstore. The database model is conceived as list of datapoints with dimensions and dimensional values.

The cellstore is an alternative way to persist data.
Less structured than a relational database (when you don't want to bother with relations).
More structured than a raw document store.
At compile time, you work with static datapoints that are primitive and extendable.
At runtime, you work with any Haskell type, giving you maximum flexibility when persisting any data.

= GHCJS =

'''Homepage''': https://github.com/ghcjs/ghcjs

'''Contact''': Luite Stegeman

'''Required skill level''': Intermediate - Expert

I'm working on some code generator improvements to improve performance, code size and to make debugging the compiler easier. I'm looking for good real-world test cases that are relatively easy to run without the browser, that can be used to keep track of performance.

If you have trouble with GHCJS, want a new feature, or want to know how to best do something, I'd be happy to help out.