gabriella439/post-rfc

Blog post previews in need of peer review

post-rfc's Issues

Convert to wiki format

Hi

This is a great resource. I'm very new to Haskell, and so I really value seeing what's 'best-in-class' for a particular use case or application domain, and learning more in general about the general libraries.

Would you be interested in converting this to a wiki format for better browsing in and out of the categories? This is something I can do in a PR, if there is interest.

Check out `gtk3`

Charles Durham (@ratzes) reported that the gtk3 package was more mature and easier to use than gtk. This is just a reminder to myself to check it out more deeply when I have time

Link to The Yesod Book is wrong

ARM support significantly more stable as of GHC 8.0.1

GHC 8.0.1 fixes the "ARM is generally a disaster" bug (https://ghc.haskell.org/trac/ghc/ticket/11206). This doesn't address all of the issues that you mention but it's a huge step forward. Not sure if it brings it into the "Mature" category but at least into "Borderline Mature". What do you think?

Type-Driven Development Section

This section has quite a few issues. One in particular stands out, which is this:

The biggest advantage of types is that they can prove the complete absence of programming errors for all possible cases, whereas tests cannot examine every possibility

This is not true. Perhaps one could modify it to say that types can prove the complete absence of type errors, but "programming errors" implies logical errors, too, which type checking can't detect. (IMHO).

debugging

It would be great to see a section on debugging and troubleshooting code in sotu.md

Textbooks to add

The following are pretty not too bad:

• Thinking Functionally with Haskell - Richard Bird
• Programming in Haskell - Graham Hutton
• The revised report - Simon Peyton Jones, et al (while not a textbook, it's obviously incredibly valuable from a pedagogical perspective)
• Parallel and Concurrent Programming in Haskell - Simon Marlow

However, they're all quite a bit outdated, and the newer books seem to not written by people with less than 10 years programming experience. Real World Haskell is also quite good but is quite long in the tooth.

I don't know if I'd class the textbook situation best in class by any means. I think perhaps that it's fair to say that the textbook situation in Haskell is severely lacking in updated or good beginner material.

Most of the textbooks I've seen are stupendously dry, with the exception of the LYAH style textbooks which is kind of silly and at times irritatingly distracting, and potentially quite confusing.

Add a subsection on code formatting tools like hindent and stylish-haskell

I think automatic code formatting is a "common programming need", so I think it deserves its own subsection.

For the rating, I'd say it's currently immature at best – stylish-haskellish AFAIK doesn't reformat code blocks apart from alignment, hindent is buggy and has questionable style choices.

Explain Haskell/Java performance comparison

Haskell's performance is excellent and currently comparable to Java. Both languages give roughly the same performance in beginner or expert hands, although for different reasons.

I have a hard time understanding what this means. Would you mind explaining why this is the case, i.e. listing the reasons?

Unicode maturity

Would it be a good idea to add a note about Text/String coexistence ?

As you said yourself, this might be the biggest Haskell annoyance ever ;-)

Mention the `megaparsec` library under Parsers

Possibly replace parsec?

The book "Haskell programming from first principles" has been published

This section says it needs changing once the book is out:
https://github.com/Gabriel439/post-rfc/blob/master/sotu.md#education

Please add Image processing

Hello
First of all thanks for making this status review.

I suggest to add a section on image processing.
Notable libraries includes: friday, JuicyPixels etc
But i can not judge the maturity of them.

Best regards

Broken link in State of the Haskell Ecosystem

The link in sotu.md with the text of

Oden restrospective on rewrite from Racket to Haskell 

leads to a 404 page.

OpenCV-3.1 bindings in the making

I would like to propose adding a reference to our OpenCV-3.1 binding to the Computer Vision section. The library is not complete nor released to hackage yet. However it's already very usable and used in production. See:

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

Machine Learning libraries

This library wasn't inlcuded in the machine learning section: https://github.com/tensorflow/haskell

Haskell bindings for R and Spark

There is a library for writing Spark applications in Haskell (still beta per the site README)

• Sparkle

There's also a library for mixing in R and Haskell code

• HaskellR

Disclaimer:

• I am not associated with tweag.io
• I haven't tried the above libraries and - as a Haskell noob - nor do I have the skills to evaluate them

Front-end web programming: mention templating

Another area for improvement, IMHO:

• Haskell tools tend to focus on building HTML pages without writing HTML. That's cool, but not appropriate for everyone. Projects to watch: Hastache for Mustache templates (fairly mature), and @sourrust's Karver (inspired by Jinja) which finally provides some whole-page HTML templating.

Please add FregeFX for desktop user interfaces

FregeFX is a Frege (Haskell for the JVM) language binding for JavaFX, the desktop UI toolkit for Java.

Add Front-Row education to Server-side programming

This is just a reminder to myself

Add 'streaming' to the Stream programming section

https://hackage.haskell.org/package/streaming
https://github.com/haskell-streaming

Tutorials mentioning streaming along pipes and conduit:
https://www.tweag.io/posts/2017-07-27-streaming-programs.html
https://www.tweag.io/posts/2017-10-05-streaming2.html
https://www.tweag.io/posts/2017-11-01-streaming-and-foldl.html

Hyperlink package names

It would be nice for package names to be linked to hackage. If you're happy to merge it, I'll send a PR with this done

Haskell pretty printer (best of class ?)

It feels odd to me to have wl-pprint / ansi-wl-pprint as "notable libraries" in a "best of class" section.

I don't think there is a "best of class" pretty printer for Haskell. See this thread:

https://www.reddit.com/r/haskell/comments/32jr3f/new_maintainer_for_wlpprint/

Shouldn't "Better, faster binary serialization" be also added to "Serialization"?

As a followup to Faster binary serialization?
I'm referring to https://github.com/meiersi/HaskellerZ/blob/master/meetups/20150529-ZuriHac2015_Duncan_Coutts-Better_Faster_Binary_Serialization/binary.pdf

Incremental Development

Hello Gabriel. About the same time that I stumbled upon Haskell I was also being taught the practice of incremental development techniques (TDD and so forth). Haskell's type system in general, partial type signatures, type holes, mature testing, purity, and laziness, make the Haskell experience, IMHO, "Best In Class" in the Incremental Development category. Incremental development is a popular topic and perhaps it deserves a section in this fine article.

Links to the "Types / Type-driven development" and "Parsing / Pretty-printing" sections don't work

The / in the links of the "Types / Type-driven development" and "Parsing / Pretty-printing" sections should be -- instead of -.

Add Earley to notable parsing libraries?

Not sure how mature it is, but I've had success with https://hackage.haskell.org/package/Earley.

Some more stuff for machine learning

I think there are some additional promising libraries in the area of machine learning.

• Most exciting from a propaganda perspective, there are Haskell bindings for Tensorflow. The library is hosted by the tensorflow organization but states that it is unofficial. It seems like it might be someone's 20% project.
• The ad library for automatic differentiation is arguably best-in-class. Computing derivatives/gradients is a fundamental operation for a lot of machine learning.
• There are several still-immature pure Haskell neural network libraries that use ad for backprop, including neural and grenade. The type system is used to ensure that input/output types of each layer of the network are consistent.
• The monad-bayes library is under rapid development (new commits ~daily) and has the potential to be very good for probabilistic programming. It is only on github now, won't be published to hackage until it is more stable.

I think ad could probably be considered mature. The rest less so.

Concurrency

I'd rate this best in class. We can do Erlang-style single machine concurrency, JVM-style, have the best STM implementation, have MVars, cheapest green threads, OS threads and CPU pinning are available if needed, LVars etc.

Also see: https://news.ycombinator.com/item?id=10071905

I have a hard time knowing why this is anything other than best-in-class unless concurrency implicitly includes "distributed systems", which I don't believe it does.

See, even you were thinking it

Add "Vertical Scalability" section

I don't know what is the right name for it, but currently there's no data in SOTU on Haskell performance on larger and more stressed servers. For example:

• GC performance on large heaps and strange allocation patterns (e.g. all data are essentially static, or the younger generation is large etc) compared to some 4 allocators of JVM
• performance on many-core (some 40+) machines which tend to be NUMA
• ability to saturate high-end network cards and drives, e.g.:
  • SSDs still require deep queues to get full IOPS, IOPS and/or bandwidth are so high that bottlenecks appear in unexpected places
  • apache spark- or MPI-like network load, where a lot of data are moved across 40 gbit links (40GBE, ifiniband, myrinet, rack-wide PCIe switches - whatever)

Bad IO-stack can hurt performance, and so far I've seen only the performance of socket listener and I think there were some works on NUMA-scalability of GHC at Facebook.

Another issue is that if you cannot buy enough RAM (and many guys assume that you always can have 4x ram than you actually need) many strange things happen:

• GC requires some empty space, so this RAM is essentially wasted compared to (say) GC-free Rust
• You want to pack your data as dense as possible (and GHC tends to have huge overhead because of pointers/thunks/boxes/whatever) - e.g. try to put a lot of key-value pairs into a dictionary and you'll see that GHC uses way too much RAM than Python with naive code, because Python/Perl/whatever hashmaps are extremely tuned over years

Server-side web programming

Thank you for your sotu post. However as a newbie to Haskell and long-time (and suffering) PHP programmer I can't share your assessment in regard to "Server-side web programming". Haskell is barely usable in this area, IMHO.

Of course I'd love to use a better language than PHP. But the sheer size of the PHP ecosystem in the end leads to the availability of at least a few impressing frameworks and libraries.

When I compare it with the PHP symfony framework, I see the following mising pieces in the Haskell world:

• No library for authorization (not authentication!) like Java Spring Security or PHP Symfony Security
• No equivalent for dependency injection to easily override services
• No standard way to override HTML templates (e.g. in Yesod)
• No established way to configure a web application and have different configurations for staging, live, development, ...
  • No way to configure email delivery different for production and development, e.g. send all dev emails to one catch-all address
• No event system to easily hook into different phases of request processing
• No debug toolbar like in Symfony: http://symfony.com/blog/new-in-symfony-2-8-redesigned-web-debug-toolbar with informations like:
  • All database requests issued for this http request
  • Emails sent during the request
  • profile information
  • all details about the request, response and session information
  • all events fired during the request
  • form data and possible validation errors
  • security details of the logged in uses: username, roles
• No bundle system so that one can compose a web application from components. Yesod subpages are not sufficient since they are subpages and not something I can use as parts of the main page.

Of course Haskellers tell me that I'm doing it wrong and that I won't need all this stuff in Haskell. But still there's no book that provides me with proven best practices to solve my problems. For example I want to make gitit2 usable for different use cases, different authorization concepts and different ways to render page. I've no idea how to do this.

So I'd consider Haskell to be promising but immature for web app development.

Hotload Coding

It'd be good to comment on the state of hotload coding in Haskell.

What do I mean?

I mean something equivalent to figwheel in clojurescript for the browser story, (https://github.com/bhauman/lein-figwheel) or REPL-driven development for the clojure story.

ie http://hackage.haskell.org/package/dyre or maybe http://hackage.haskell.org/package/hotswap tho it seems to have been neglected for about 3 years.

Effectively, you wire your code up in the REPL where you can interact with the live system as it runs, adjusting data and as you modify your source, interacting with the system if it has a live interface (like, say, a web app), the REPL swaps the newly redefined functions out with it as you do live code replacement or reload your files (often triggered by saving).

This RAPIDLY speeds up development of interactive systems as you don't have to "change the state of the system" every time you adjust your source code.

One more debugger with break-points

Phoityne for Visual Studio Code
https://marketplace.visualstudio.com/items?itemName=phoityne.phoityne-vscode

It has lot of debugging features and works via GHCi.

ad - automatic differentiation

This has always stood out as an interesting and uniquely-haskell library. I'm not sure where it should go.

I'd be happy to submit a PR with a suggestion of a good category. Data science?

https://hackage.haskell.org/package/ad

Generic programming is missing

Databases: RDF / Triplestores

Just wondering if you'd consider mentioning something about Haskell support for these database types.

Add "Podcasts" section

There are not many Haskell-specific podcasts that are currently airing new episodes, however there are quite a few dedicated to the larger FP community. I wonder if there is interest in adding these? Here are some candidates . .

Haskell-only

• The Haskell Cast

Non-Haskell, but FP, CT, ST, TT, NLP, etc.

• Type Theory Podcast
• Functional Geekery
• Magic Read Along
• Cognicast

There's also a website called fpCasts which serves as a kind of aggregator. Dozens of episodes will also pop-up if you filter the more popular software engineering podcasts for 'haskell', 'functional programming', etc.

Add more languages?

Under "Some compilers written in Haskell", maybe mark oden as "(no longer in active development)" and add

1. Verve
2. Sixten (disclaimer: I'm a minor contributor.)

both of which seem to be more developed than oden.

Please add a section on Random Number generators

Chart examples

Nice Document!

But...

To pick on one library as an example, the Chart library does not have a single minimal end-to-end code example that I can find anywhere in the Hackage documentation.

Whilst the Chart library is a long way from perfect. I don't really understand this criticism. The wiki (https://github.com/timbod7/haskell-chart/wiki, referenced from hackage) has a dozen or so examples of working code.

Education Resources lacks intermediate or advanced material

While it's obvious to focus on beginners in this section, the intermediate and advanced material is somewhat lacking. There are numerous papers that are useful in this regard, and it'd be great if there was some guidance on discovering papers, blog posts and other more advanced material too (like... start with these papers, then look in their reference sections and bibliographies for more papers, use the topics you discover as search terms to find more papers like this, blog entries on it, etc).

As first example, I'd consider Yorgey's monoid paper as basically indispensible reading for anyone who wishes to gain a deep first step into a topic which underpins much of computation (let alone only computation in Haskell).

This is something almost exclusively available to Haskell... we have a plethora of academic resources available to us, and we're almost the default language for exploring many topics at the connection point between mathematics and computation.

As with many things in Haskell, while learning the basics of a topic under question is good, useful, and at times reasonably tricky in itself, a mere discussion of how it's implemented, what it is on a face value and a couple of examples is not where the most interesting regions, or even the meat of the difficulty of the topic often lies — usually it lies in an exploration of the ramifications of the choices made in whatever packages is under discussion — that is, in using it across many varied contexts.

I firmly believe this is the reason Monads have been traditionally difficult to understand, aside from the nomenclature issue of Haskell that seems to go largely unnoticed (that is, when it comes to typeclasses, we use the same words for a value of a type as for a type as for a typeclass as for its instances: point in case the answer to the quesiton "what is monad?" Maybe is an example of a monad, Just 5 is an example of a monad, Monad typeclass is monad, and the monad instances for each type are how a monad is defined — this is inherently confusing).

That's to say, the core reason pieces of Haskell are difficult to undersatnd is that they're often extremely abstract, and in teaching it, often the ramifications are skipped over, which is where the subtleties, practical value and interesting parts of the topic usually reside.

BTW, love how the SOTU is taking shape!

"Mature" package management with a two-month-old tool?

Stack looks really cool, and much better than cabal-install, but it's too young to make an area "mature" — indeed, I run into a bug within 5 commands (commercialhaskell/stack#665).

In other mature areas, "mature" is used as I'd expect: tools/libraries are old enough to be (next to) bug-free (say QuickCheck).

(Maybe package management is mature according to the definition you give, but then I disagree with the definition/the terminology/the lack of intermediate degrees).

ratings

Hi,
congratulations for this work. I have a small issue with the ratings: "Best in class" and "Bad" seem to express a judgment on value, while the two others are about maturity. For example some domain could be seen as mature (i.e. well tooled, nothing to do more) but "bad" because Haskell is simply no good at that (e.g. embedded).
Another suggestion: swap "Application Domains" and "Programming Needs" sections, because the reading becomes quickly depressing: already "Immature" at the third bullet...

"parsers" might could be mentioned side-by-side with Trifecta

http://hackage.haskell.org/package/parsers

And possibly deserves more prominent billing. I'm not aware of an equivalent in any other ecosystem where you can write a parser once, have a super-nice parser with informative errors for development, then flip a type, and get a fast parser for production.

http://happylearnhaskelltutorial.com

I wonder if you'd consider adding this resource (and maybe mentioning on your blog, too!)

:)

Game and GUI programming

Hi! first, I wanted to say thanks for making this document!

I would like to share a few points about Game and GUI programming in Haskell:

Regarding GUI programming in Haskell: One front that seems to be actively developed is reflex-dom which targets both ghcjs and ghc. when targeting ghc it uses webkitgtk3, so hopefully we'll be able to build nice desktop GUI application in Haskell soon :)

Regarding Game development in Haskell, there are also a few fronts:

• sdl2 - there is active work on new api for SDL2
• LambdaCube3d - Targets OpenGL Haskell backend (or WebGL PureScript back-end)
• Luminance - a young work-in-progress "OpenGL safe wrapper"
• Hickory - Still very initial game engine that hasn't been updated in a while but worth checking out
• Cove - It still is possible that one day Chucklefish will release Wayward Tide and open source their Haskell game engine, Cove :)

Also, I definitely felt as I had a success story with Haskell in my B.sc. final project. Building an interpreter for a purely functional, implicitly parallel language was a breeze because of the book Parallel and Concurrent Programming in Haskell that you mentioned, the threadscope tool for analyzing parallel programs and the parallel library. This is almost all the code I needed!
I would also add Write Yourself a Scheme In 48 Hours as a good, beginner friendly, project based tutorial on the subject.

Thanks again!
Gil

No mention of learning resources

Lack of great beginner resources is one of the most fundamental problems in Haskell to date IMO.

I'm aware there are major efforts being made in improving the situation, (for example http://haskellbook.com), but the fact that this is left out of your state of the ecosystem document kind of speaks volumes about how unimportant this is deemed by most Haskellers.

For a language which has had as much influence on the programming community and understanding what it is we do as programmers as Haskell has, I think we could afford to be better at explanation.

When learning and programming Haskell you almost have no choice but to be aware of what you're doing when you're doing it. This is so different than any other language, and I feel that it's actually the source of why it's so difficult to learn Haskell for people: you're not just learning a language, you're learning how to adjust and change your thinking as well. You're learning what you're doing as well as how to be able to do it.

So if you could consider putting an educational resources section in, that'd be very pleasant :)

Add "Community and Help" section

• How do I find a library?
• How do I find a solution?
• How do I find the most idiomatic way to solve this problem in Haskell?
• There are numerous blogs with new ideas (Comonad Reader etc)
• There are many user groups in different languages in IRC, Gitter, Telegram, Facebook - you name it.
• StackOverflow has 3 useful sites for a Haskeller: StackOverflow, CodeReview and ComputerScience (and what is more important is that if you ask a harder question which only Edward Kmett or Don Stewart can answer they probably will there, up to the point of https://ro-che.info/ccc/2)

Consider adding Postgrest to server-side or DB section

Postgrest is a service that uses its own stack of popular libraries to generate a REST API that reflects a Postgres schema.

I rarely get to work with Haskell but I am using a GraphQL project (link) which was heavily inspired by the Postgrest project and it stands out as an extremely useful service for small teams that want to maintain a single source of truth and not worry about optimizing every query by hand.

Add 'Spock' to server-side programming libraries

I'd argue that Spock deserves a Spot in the server-side programming libraries, too. It fits well between the "gap" between scotty and the yesod group as it is still pretty simple but provides most features for medium sized applications. It's commercially used in production for over a year now by different companies. What do you think?