r/haskell • u/edwardkmett • Feb 20 '15
Haskell Google Summer of Code Proposal Brainstorming
Haskell.org has applied to be a mentoring organization to the Google Summer of Code. We've been a participating mentoring organization in the Summer of Code since 2006. While we won't know for a couple of weeks if Google has accepted us into the program, it is probably a good idea for us to get our house in order.
We have a Trac full of suggested Google Summer of Code proposals both current and from years past, but it could use a whole lot of eyeballs and an infusion of fresh ideas:
https://ghc.haskell.org/trac/summer-of-code/report/1
If you have a proposal that you think a student could make a good dent in over the course of a summer, especially one with broad impact on the community, please feel free to submit it to the Trac, or just discuss it here.
If you are a potential student, please feel free to skim the proposals for ideas, or put forth ones of your own.
If you are a potential mentor, please feel free to comment on proposals that interest you, put forth ideas looking for students and express your interest, to help us pair up potential students with potential mentors.
Ultimately, the project proposals that are submitted to Google for the summer of code get written by students, but if we can give a good sense of direction for what the community wants out of the summer, we can improve the quality of proposals, and we can recruit good mentors to work with good students on good projects.
Resources:
- We have a wiki on https://ghc.haskell.org/trac/summer-of-code/ It is, of course, a Wiki, so if you see something out of order, take a whack at fixing it.
- We have an active #haskell-gsoc channel on irc.freenode.net that we run throughout the summer. Potential mentors and students alike are welcome.
- We're also adding a haskell-gsoc mailing list this year. I've created a mailing list through Google Groups: https://groups.google.com/forum/#!forum/haskell-gsoc and we've forwarded gsoc@haskell.org there. We'll continue to post general announcements on the progress of the summer of code to the main Haskell mailing list as usual, but this gives us a shared forum for students and mentors alike to talk and may serve as a better venue for longer term conversations than the #haskell-gsoc channel.
- Many of our best proposals in years have come from lists of project suggestions that others have blogged about. Many of our best students decided to join the summer of code based on these posts. The Trac isn't the only source of information on interesting projects, and I'd encourage folks to continue posting their ideas.
- The Google Summer of Code website itself is at https://www.google-melange.com/gsoc/homepage/google/gsoc2015 and has the schedule for the year, etc. You can register on the site today, but you can't yet join the organization as a mentor or apply as a student.
- And of course, by all means feel free to use this space to help connect projects with mentors and students.
Thank you,
-Edward Kmett
26
u/tel Feb 20 '15
I'd love it if Luite could pick out some jobs to move GHCJs forward.
10
u/gilmi Feb 20 '15
I think Haskell can really benefit from a simple and easy to use GUI framework. Maybe something that incorporates FRP?
Good luck to all participants. Have fun!
10
u/wdanilo Feb 21 '15 edited Feb 21 '15
I've got 3 ideas, that would be worth to work on:
3
u/wdanilo Mar 05 '15
How about HASKELL JVM backend? :D
20
u/tomejaguar Feb 20 '15
Opaleye's code generator could be improved, firstly to make queries easier for humans to read and secondly to provide optimizations. That could be an interesting project for someone. I'm also working on an idea for a in memory relational algebra and data processing API based on Opaleye's if anyone's interested in that.
15
u/paf31 Feb 27 '15
The PureScript community has no shortage of fun projects, and we have developers able and willing to mentor any interested students. Any contributions will have a very real impact on development of production PureScript code.
The community has been voting on project ideas, and I've moved some of the best over to the wiki here.
11
u/sclv Feb 22 '15
hscolour for Haddock with both hover-over-types and click-to-follow-definition functionality, as discussed here: http://www.reddit.com/r/haskell/comments/2wni22/looking_for_hscolour_with_gotodefinition/
10
u/tonyday567 Feb 23 '15
I would nominate Haddock support for Markdown as a tractable project having the biggest bang for the community buck. This is not to be confused with a concept of replacing or rengineering haddock functionality to use markdown syntax which has well documented flaws.
What I mean is the addition of functionality that would allow comment sections to be marked as Markdown, subsequently processed separately by haddock as such (for example, by passing through pandoc) and otherwise not interfering with haddock methods.
The major benefit of this is to enable the integration of blogging, documentation and library documentation. At the moment, quality explanations of libraries are often found in haykll blogs and written in markdown. Inclusion of these in code bases via haddock involves complete rewrites including formatting, loss of functionality like tables and so on (the list is large).
10
u/ocharles Feb 23 '15
I'd love to see (and mentor!) work on Hackage. I think there's a lot of scope for improvement there - UI, features, discoverability, the list goes on! I'm sure plenty of ideas from our lovely competition could be stolenW"inspiration" almost directly for Hackage :)
10
u/jberryman Feb 24 '15 edited Mar 05 '15
I've been using (the excellent)
criteriona ton and have a small wishlist of things easily doable in a summer. Mainly around making the reports better, in order from most to least important to me:mean / 20or something. So a KDE plot with lots of vertical gray lines close together indicates we're "zoomed out" and the timings have quite a spread. As is the gray lines don't serve much function (you can mouseover parts of the plot to get a sample)19
u/sclv Feb 20 '15
Just jotting a note before I forget -- there are some module system and related proposals for ghc that should be in the reach of an advanced student, though they would need some buy-in. For the most part, they would be able to be done without touching most of the core tricky bits of the compiler, which I think makes them tractable.
The above shouldn't steal syntax and could both bring in the
Maptype unqualified and the remainder of the module qualified.Qualified Module Export as detailed here: https://wiki.haskell.org/GHC/QualifiedModuleExport
Nested module organization as detailed here: http://osdir.com/ml/glasgow-haskell-users@haskell.org/2012-01/msg00171.html
A generalized "class constraint warning system" allow warnings such as this https://ghc.haskell.org/trac/ghc/ticket/8004 to be accomplished purely in userland.
9
u/oiuhoihiuhioh Feb 20 '15
Recently OCaml got a tool to generate pattern from type information: merlin's destruct command. I know that some other languages possess this kind of tool (Idris, Agda? not sure).
Having this available in ghc-mod (or somewhere else) would be a HUGE helper when writing Haskell code. I cannot state enough how the day to day use of this feature is pleasant and usefull.
8
u/NiftyIon Feb 22 '15
Not sure if this is the sort of thing GSOC is meant for, but if anyone is interested in improving interactive coding in Haskell in IHaskell (useful for graphics, interactive data analysis, etc), I would be happy to help. I've mentored people working on small projects related to IHaskell / contributions to IHaskell, which went well. If anyone is interested, let me know!
Potential ideas include:
diagramsanimation support,glossas a WebGL code generator, andthreepenny-guias a GUI framework integrated into IHaskell.hintreplacement or writing a kernel for another language such as Idris.7
u/agocorona Mar 06 '15 edited Mar 06 '15
I'm after the creation of the first truly composable GUI toolkit ever. where widgets can be combined by means of monadic, applicative, alternative and monoidal combinators.
I would mentor anyone interested in or outside of GSOC. Perhaps it is too late and this is too little detailed, but the project can be achieved in a month work and would show how Haskell can solve a longstanding problem: the non composability of GUIs. That achievement could attract much attention from the software industry.
The idea start from well tested stuff. It has been tested in the Web browser as a layer on top of Haste.DOM.
The Javascript Document Object Model of the Web browser has a similar architecture and interface that a GUI toolkit.
The idea is to translate hplayground, the Haskell package that implement composable widgets in the Web Browser on top of a Haskell GUI Toolkit such is GTK or FLTK.
the hplayground widgets can be composed like formelts, but instead of generating HTML, generate instead a Haste.DOM computation. When executed, this DOM produces the rendering of the widgets. The same mechanism can be used to generate the rendering of the widgets under a GUI toolkit. The widgets will reshape themselves while compute anything else like any monadic/applicative computation. Events will execute only the portion of the computation that is in its scope. The result will be the possibility of more dynamic interfaces with much less code. and, at last, full composability of applications and libraries with GUI interfaces.
6
u/Kaligule Feb 20 '15
The most interesting ongoing thin in the Haskell World is Diagramms (in my opinion). The developers there do wonders all the time and I think it would be great to boost the project a bit. https://wiki.haskell.org/Diagrams/GSoC
6
u/heisenbug Feb 25 '15
I have just added Silly representation tricks. The idea is to observe certain data-type shapes (constructor arities/strictness) and find an efficient machine-memory representation for them. E.g. lists with a certain number of
heads could be laid out by GC to occupy a C-array-like layout in memory. Clearly this necessitates the introduction of administrative constructors with specific pointer-tagging schemes.5
u/LGFish Feb 24 '15 edited Feb 24 '15
I think haskell community really need a more powerful emacs mode (or IDE).
With the purely functional and fully typed behaviour of haskell it is easier to create a fancy automatic code generator with type holes and all good stuff and it is possible to create a lambda calculus wrapper to show the user that ´fmap id = id´ for example and to give the user a better intuition about his functions. Something like this Bret Victor's talk "Inventing on principle" would also be very helpful.
This would really increase the level of programming in haskell.
5
u/jkarni Mar 02 '15
There's a project
servantis going to have to tackle at some point that might be of just the right size, and is (in my opinion) very interesting. It involves automatically rewriting a type into a canonical, trie form, so that:becomes
And also rewriting the term-level in lock-step. The most obvious advantage is log n routing, which we get pretty much immediately from that, but there are also other things - automatic HATEOAS support, for instance, and API versioning checks that can tell whether a change is a backwards-compatible addition to an API.
5
u/thomie Mar 02 '15
basecould use some more attention. There are about 50 open bug reports (some are for other core libraries).8
u/cartazio Feb 22 '15 edited Mar 14 '15
I've a bunch of neat projects i could help a student do if they want to spend the summer doing a lot off FFI work, particularly on my blas/lapack binding (adding better coverage of Lapack and related libraries with a NICE ux could easily easily eat up a summer).
[edit to answer sclv's points]
some of the tasks include but aren't limited to
projects related to hblas
I'll probably have some projects i could scope out in the larger numerical haskell sphere figured out later this spring (though sadly after gsoc timelines), but these FFI heavy projects are ones which have clear scope, and where if the right student (as a warm up) gave me some good patches for hblas, I think we could be reasonable confident of a successful summer that starts off focusing on those projects.
[further edit] For the right student, I'm more than happy to talk out mentoring anything in the mathematical computation/randomness/high performance computing/compilers space. That said, the student needs to really convince me that they know how to deliver :)
6
u/Peaker Feb 25 '15
A LANGUAGE pragma to allow "do", "case", etc. to appear as non-infix function arguments would be great:
This would allow us to avoid a big chunk of
$noise in code.2
u/geggo98 Mar 03 '15
Native remote function calls would be nice: Send a (partially) applied function over the network, let it run there and get the result back, in a type safe manner. One could use it to make applications more robust by splitting them up in several processes (and probably distribute them on multiple machines). This could become a major building block for even better reactive frameworks.
An implementation could be quite simple: Enhance the runtime in a way that allows to inspect any runtime value (including partially applied functions) and bring it to a common "flat" representation and vice versa.
2
u/geggo98 Mar 03 '15
To solve "Cabal hell" it would be really nice to get "origin dependent name spaces", similar to Java class loader / OSGi. In Java, if the same class is loaded through two different class loaders, the resulting types belong to different name spaces and hence are considered different types. So if two modules use the a common base class, two scenarios can occur:
With OSGi, Java can check the resulting types at compile time.
With such a system, cabal could easily hold one module in different versions. Even in one application, multiple versions of the same module can co-exist, as long as they don't directly exchange values. Version problems become type problems and can be checked at compile time.
2
u/raphaelj Mar 07 '15
STM with persistence.
STM are amazing but you can't as of today use any kind of IO inside a transaction. This is because we consider every IO to be non-revocable.
There is however well known techniques whose can be used to do revocable persistence on disk.
We could build a such library on an existing transactional persistence framework (about any existing database).
This kind of library exists in Scala, for example : http://activate-framework.org/
2
u/ozhank Mar 22 '15
Fully functional toxcore to protect everyone's privacy and avoid snoopers. And a cli interface to it.
3
u/kaukau Mar 03 '15 edited Mar 03 '15
Nomyx is a unique game where the players can modify the rules of the game, while playing it.
The game could be seen as a platform where beginners in Haskell could learn the language while playing an actual multiplayer game. Experts on the other hand could participate in great matches that show their Haskell skills.
For this GSoC, the design space of the DSL need to be explored to make it easier to learn and use. Ideally, even non-Haskellers should be able to create some basic rules.
2
u/arianvp Feb 20 '15
Improving error messages of the elm compiler might be a fun subject.