gabriella439 / post-rfc Goto Github PK
View Code? Open in Web Editor NEWBlog post previews in need of peer review
License: Creative Commons Attribution 4.0 International
Blog post previews in need of peer review
License: Creative Commons Attribution 4.0 International
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 :)
Not sure how mature it is, but I've had success with https://hackage.haskell.org/package/Earley.
The following are pretty not too bad:
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.
This is just a reminder to myself
Just wondering if you'd consider mentioning something about Haskell support for these database types.
I think there are some additional promising libraries in the area of machine learning.
ad
library for automatic differentiation is arguably best-in-class. Computing derivatives/gradients is a fundamental operation for a lot of machine learning.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.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.
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
This library wasn't inlcuded in the machine learning section: https://github.com/tensorflow/haskell
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.
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.
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:
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).
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 . .
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.
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.
There is a library for writing Spark applications in Haskell (still beta per the site README)
There's also a library for mixing in R and Haskell code
Disclaimer:
The link in sotu.md
with the text of
Oden restrospective on rewrite from Racket to Haskell
leads to a 404 page.
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?
Another area for improvement, IMHO:
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
This section says it needs changing once the book is out:
https://github.com/Gabriel439/post-rfc/blob/master/sotu.md#education
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.
The /
in the links of the "Types / Type-driven development" and "Parsing / Pretty-printing" sections should be --
instead of -
.
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?
Phoityne for Visual Studio Code
https://marketplace.visualstudio.com/items?itemName=phoityne.phoityne-vscode
It has lot of debugging features and works via GHCi.
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:
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:
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.
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
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!
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 ;-)
I wonder if you'd consider adding this resource (and maybe mentioning on your blog, too!)
:)
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...
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
It would be great to see a section on debugging and troubleshooting code in sotu.md
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?
Possibly replace parsec
?
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?
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/
FregeFX is a Frege (Haskell for the JVM) language binding for JavaFX, the desktop UI toolkit for Java.
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:
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
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.
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).
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
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.
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:
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.
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.
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google ❤️ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.