"So I read a couple of tutorials online and went through the famous Learn You a Haskell for Great Good ! It was a long and painful journey - which is not over yet. After some retrospection I wanted to share my own introduction to Haskell based on my python experience. What I wished I had learnt first and what I wished I learnt later down the road."
Haskell needs more content like this to show people how approachable it is, and especially when they're more up to date and more in line with recent best practices in using haskell.
As long as we're not all doing burrito tutorials, the more people that engage with Haskell (and write posts about it), especially simple, straight to the point ones like this the better.
I personally have written a guide on how to build practical APIs in Haskell that is now quite outdated[0], and while I tried to go from zero, it is almost certainly not a good entry guide. Glad to see more people taking stabs at it.
[0]: https://vadosware.io/post/rest-ish-services-in-haskell-part-...
I mention other, better resources in my haskell study plan: https://github.com/soupi/haskell-study-plan
* I went through LYAH, but at a certain point I felt like it wasn't doing me any favors by sweeping some of the inherent complexity under the rug. So I started listening to talks by SPJ, Wadler, et al. and reading the papers they wrote in the 1990s-2000s. See for instance the SPJ talk on Typeclasses [1], the Beautiful Concurrency paper [2], and the one about Monadic Parser Combinators [3].
* Don't just read stuff, run it in GHCI, or better, learn how to set up a minimal project with Cabal/Stack.
* I spent a lot of time reading about type theory and category theory. This isn't strictly necessarily, but it gives me context and perspective on the language.
* Haskell Language Server integration with VS Code was a lifesaver. Being able to hover over an expression and see the inferred type makes it so much easier to reason about Haskell code as a beginner.
* To understand monads, it was most helpful to see how do-notation and the >>= and >> operations desugar into a sequence of lambda abstractions. In general, I tried to find as many different examples of monads as possible. Seeing monad comprehension syntax really helped as well.
* After a while, I could read Haskell, but felt absolutely lost when trying to write it myself. So, I started working on a small cli that forced me to learn stuff like: how to manage a monad transformer stack, how to make http requests, how to parse and serialize json, how to write to a database, etc.. It took months and months, and I would often get stuck and have to go and spend a few weeks learning something else. But I always had a project to come back to and apply what I learned.
[1] https://www.youtube.com/watch?v=tqx9_MQbQ_c
[2] https://www.microsoft.com/en-us/research/wp-content/uploads/...
There are powerful applications of category theory to other parts of computer science. If one keeps in mind that Haskell is Just Another Programming Language, then one can apply category theory more generally and fully.
[1] Haskell/Category Theory https://en.wikibooks.org/wiki/Haskell/Category_theory#cite_n...
[2] Bauer 2016, "Hask is Not a Category" http://math.andrej.com/2016/08/06/hask-is-not-a-category/
[3] A reddit comment in response to #2, https://www.reddit.com/r/haskell/comments/4wk0gs/hask_is_not...
[4] StackOverflow, "Is Hask even a Category?" https://stackoverflow.com/questions/48485660/is-hask-even-a-...
Newcomers should absolutely use ghci commands like :t :type https://downloads.haskell.org/ghc/latest/docs/html/users_gui... to tinker and experiment. Also :info and :instances https://downloads.haskell.org/ghc/latest/docs/html/users_gui... once they start learning about typeclasses.
Typed holes can also be really helpful https://downloads.haskell.org/ghc/latest/docs/html/users_gui...
I am currently just before this stage. I can use Haskell for stuff like projecteuler.net problems but I haven't written a single useful, real-world program without copy-pasting some code.
I tried doing something with http requests to an API for stock trading but I failed to understand how to make a request. There are a few packages but they all have their flaws (e.g. no https) and aren't really developed that much.
My question is: did you write all these things with mostly only the Prelude of Haskell or did you use packages for all those things you listed (http requests, json data, databases etc.)?
I'd love some pointers in the right direction for http requests as well as maybe ideas for initial real-world project ideas that are exciting (I don't care for the standard ones you find online).
The "req" package is very intuitive to use for requests, and plays nicely with "aeson" for parsing JSON. I'm also using "persistent" to manage a sqlite database.
For project ideas, try to scratch a personal itch. If you're solving a problem (or a daily frustration) that's important to you, you'll be more motivated to follow through! For me, I had been using the beets (https://beets.io/) command line tool to manage tags for my music library, but it isn't really optimized for my use case, and I thought I could do better. So I decided to write a cli [1] with Haskell to tag all my local music files with metadata from Discogs/MusicBrainz, modeled after the beets tagging loop. I'm also working on a more advanced tagging system that uses Datalog inference rules, inspired by a blog post [2].
[1] https://github.com/benrbray/borscht-hs [2] https://dodisturb.me/posts/2018-12-25-The-Essence-of-Datalog...
[0]: https://hackage.haskell.org/package/wreq
[1]: https://bitemyapp.com/blog/haskell-is-not-trivial-not-unfair...
One of those reasons is going to be that QuickCheck predates PureScript by 14 years.
Elm is beautifully simple. And it gives you such a solid foundation to learn Haskell and how to think in Haskell. Even if it's not Haskell and is a much smaller language.
4 out of 5 people will learn Haskell faster by learning Elm first, than by just focusing on Haskell. And I mean even accounting for the time learning Elm it still will be faster to learn Haskell.
EDIT: Seriously downvotes for that? Go watch some of Evan's talks on Elm, when pressed for why he doesn't implement some of Haskell's more out-there features, he states that his goal is not to appeal to Haskell devs, but to JS devs, and that he wants to keep the language palatable to them.
Eg, how do you explain things like scope, object lifetimes, and destruction without words? In C for instance, there are various non-intuitive things such as that the string "Hello" is actually 6 bytes.
IMO, syntax is the least important part of programming. It's far more important to understand what exactly that syntax does. Take for instance #include. It looks straightforward on the surface, but there are lots of un-intuitive parts to it, such as that you're effectively copy/pasting a file into your code, that you need include guards, that order can make and a.h can #define something that breaks b.h, that you need to #define _GNU_SOURCE to get some particular bit of functionality before a particular header...
You can definitely write sample code to illustrate all that but I can't think of any way of explaining "what's going on" and "why we're doing this magical looking bit here" without using words.
1) WHY: The Functional Programmer's Toolkit - Scott Wlaschin : https://www.youtube.com/watch?v=Nrp_LZ-XGsY
2) WHAT: Learn Haskell in one video : https://www.youtube.com/watch?v=02_H3LjqMr8
3) HOW: Haskell without the theory : https://www.vacationlabs.com/haskell/
It'll teach you enough to be dangerous. Obviously your learning has just begun, but with a mental platform that lets you study other resources in time and practically test things out.
I bought this years ago and it is ~1200 pages and very through. A ~600 page paper version is coming out soon also.
A small subset of Haskell makes for a spectacularly effective functional language. Visualize that this subset exists, and have fun learning it. It helps if one has seen other small languages that work, such as Scheme.
Suppose that I'm wrong and it's both closed and powerful enough. Then, fix an arbitrary Haskell type signature for some function `f`, and consider defining it as `f = undefined` or `f = f` respectively, and work out what still remains in the subset. Indeed, `undefined = undefined` is its typical definition.
While it is one person's opinion (albeit well explained) I strongly appreciated Chris Allen's efforts to evaluate existing learning material (prior to co-writing his book) as well as recommending a learning path [2]. Ultimately there is multitudinous material to study. For the textbook-like route, choose something that seems sensible and commit, leaving only when it appears to no longer be fulfilling the purpose. Juggling too many artifacts is like interrupting programmers.
I don't use VS Code but again, my elementary knowledge of the language, plus sufficiency with GHCi, meant I could stay within my Vim comfort zone. If anyone has a good single resource for configuring Vim for Haskell I'd love to see it?
[0] State of the Haskell ecosystem https://github.com/Gabriel439/post-rfc/blob/master/sotu.md [1] Functional Education https://bitemyapp.com/blog/functional-education/ (December 2014) [2] How to learn Haskell https://github.com/bitemyapp/learnhaskell
I would suggest playing w/ a "smaller" language like ML (https://learnxinyminutes.com/docs/standard-ml/) or even Hope (https://github.com/hcarvalhoalves/hopeless) to understand the sources of inspiration and grasp some concepts of FP, pattern matching and algebraic data types. The more featureful Haskell may be less confusing if you can better discern what are core concepts vs. unique features, and also avoid fixating in monad tutorials.
