WingNews logo WingNews GitHub [2]
top | item 41027265

Ask HN: What resources do you recommend for learning Haskell?

109 points| hackerthemonkey | 1 year ago

What resources do you recommend for learning Haskell?

I am working my way through “Learn You a Haskell for the greater good”

I also have a side project to learn things by doing, but was wondering what the most recommended learning sources were which people found very useful.

64 comments

order
[+] anfelor|1 year ago|reply
Perhaps contrary to most people in this thread, I think you should avoid learning lenses or category theory too early. These are great tools, but they take months or even years to master and are not required to write useful code in the language.

I find Haskell very useful for my projects, but to achieve this I restrict myself to the basic subset of the language (Haskell 2010, no fancy extensions such as type families or GADTs) and use few libraries aside from the core libraries. New features and libraries always carry a high learning curve in Haskell and less popular libraries can be buggy. Instead, you will often be more productive just writing the required functionality from scratch (and it will teach you more too!).

At Jane Street, I saw my coworkers learn functional programming in just one week. (some still struggled with monads in the second week -- if that is you, I can recommend Phil's paper: https://homepages.inf.ed.ac.uk/wadler/papers/marktoberdorf/b...). If you are learning Haskell in your free time and with no one experienced to help, it will obviously take you longer. If you have questions, feel free to post on the Haskell IRC or Reddit. Just don't worry that you need to read another tutorial before getting started :)

[+] doctorpangloss|1 year ago|reply 

    type JokeM a = IO a

    askQuestion :: JokeM String
    askQuestion = do
      putStr "How do you know someone works at Jane Street? "
      hFlush stdout
      getLine

    tellPunchline :: String -> JokeM ()
    tellPunchline _ = putStrLn "They tell you!"

    janeStreetJoke :: JokeM ()
    janeStreetJoke = askQuestion >>= tellPunchline

    main :: IO ()
    main = forever janeStreetJoke
I don't know this feels kind of verbose to me.
[+] tmountain|1 year ago|reply
I like this advice, but I would suggest adopting a prelude that has better defaults than what the language ships with.
[+] TwentyPosts|1 year ago|reply
...what are lenses? Never heard of those.
[+] matt-noonan|1 year ago|reply
A common failure mode is for people to think Haskell is some special snowflake that requires reading 50 books and papers to understand. It doesn’t. Learning by doing is definitely the way to go. LYAH is fine but not great at practical problems. Real World Haskell is somewhat out of date but better at the actual “how do I make a program that does real things?” question. Best bet is to hack until you get stuck or your solution seems too ugly, then ask for leads on Reddit or the FP discord.
[+] nvarsj|1 year ago|reply
Haven’t touched Haskell in years, but I found the best guide was Brent Yorgey’s old UPenn CIS194 online class. It contains easy to digest text lectures with follow up classwork.

I successfully taught dozens of people who had no former functional background. Just did a weekly meeting covering the lecture and prior week’s homework.

https://www.cis.upenn.edu/~cis1940/spring13/lectures.html

[+] nextos|1 year ago|reply
It's also my favorite beginners resource. And free.

Straightforward and short. Takes you to the interesting bits very quickly.

[+] ahf8Aithaex7Nai|1 year ago|reply
My biggest difficulty in learning Haskell was to distinguish the really useful from the useless. There is a lot of “academic nonsense” in Haskell (both in the language and in the code people have written) and a lot that is just broken and abandoned or unnecessarily complicated. Unfortunately, it takes a lot of time to separate the wheat from the chaff. Underneath the 50 or so language extensions, the completely outdated (and in my opinion broken) Prelude and the super frustrating and unpolished tooling and cursed lazyness hides a very beautiful and powerful, simple, productive, purely functional programming language.

To summarize, you could say that Haskell is not really made of one piece, but is something like a 34 year old, very messy academic playground.

So it might be helpful to switch to a purely functional alternative, Purescript/Elm/Gren for practical programming, or Idris/Agda to explore the more academic side.

[+] rnallandigal|1 year ago|reply
"What I wish I knew when learning Haskell" by Stephen Diehl[0][1]. It has commentary on a great deal of topics in Haskell and is very approachable. Also, learning to use Hoogle[2] will serve you well.

[0] https://smunix.github.io/dev.stephendiehl.com/hask/index.htm...

[1] https://github.com/sdiehl/wiwinwlh

[2] https://hoogle.haskell.org/

[+] lemonwaterlime|1 year ago|reply
This, and get comfortable letting the compiler (ghc) and the type system find errors for you. Change a piece of code and let the compiler tell you everywhere that is now broken. Fix it all. Continue coding.
[+] tombert|1 year ago|reply
Working through Learn You A Haskell is a good start.

After that, I honestly think you'll get the best bang-for-buck by reading library-specific tutorials. If you play with enough of the libraries the rest of the language more or less falls into place.

Conduit is a pretty ok streaming library, and has good documentation: https://github.com/snoyberg/conduit#readme

Lens gives you a lot of useful features that more or less correspond to stuff like Getters and Setters in something like Java, and the tutorials for it get into some helpful details about writing Haskell code: https://hackage.haskell.org/package/lens

Otherwise it's basically a lot of "just build shit, and don't be afraid to feel confused" and it'll fall into place.

[+] francogt|1 year ago|reply
Haskell Programming from First Principles is probably the best and most exhaustive resource on learning Haskell.

I now refer people to “Effective Haskell” by Rebecca Skinner[0]. It’s well written, modern (published in 2023) and goes into everything you need to know to use haskell in common, real world tasks.

[0] https://pragprog.com/titles/rshaskell/effective-haskell/

[+] yoyohello13|1 year ago|reply
I really liked https://haskellbook.com/. It’s long, but has exercises after each chapter which I found very helpful.

The first chapter is about Lambda Calculus which is kind of a Haskell meme at this point, but learning it actually did help me a lot to grok how Haskell programs are meant to fit together.

Other than that, just doing some basic side projects and leaning about how to use Cabal effectively should get you there.

[+] fn-mote|1 year ago|reply
I love Haskell Programming from First Principles. It has details for everything. It has plenty of exercises you help you make friends with all of the "esoterica". Once I worked with the rules (e.g. how to make an instance of Applicative), they were a lot more concrete for me.

In Haskell, when you don't understand some detail it really comes back to get you. I read LYaH and I felt like I understood the big picture, but I didn't understand that it was critical to understand the types of _everything_ in an expression that I wrote. (My own failing.)

In summary: I highly recommend. https://HaskellBook.com

My background when I read it: 10+ years programming, 5+ years functional programming, 2 attempts reading LYaH (1 successfully). I still loved it. It would have saved me a lot of grief to start with the HB instead of LYaH.

[+] viking66|1 year ago|reply
Learning haskell is like learning to program from scratch. Do you remember the your journey learning to code for the first time? If you're anything like me, that was a lot of banging your head against the wall, trying all sorts of different resources, giving up only to try again a little while later, and then one day everything starts to click. It's all part of the journey.

Haskell is so different from all the languages people tend to learn so it feels much like learning to code all over again. That being said, it's totally worth it! I'm a much better developer (in any language) thanks to all the wonderful things haskell has taught me. I'm much better at designing clean abstractions, I have more tools for solving problems, I have more fun coding, and new challenges don't scare me so much because I know I just need to go through the process and I'll come out the other side even better.

To answer your question, there was no one resource that worked for me. It was just a matter of time and effort going through lots of resources until one day my brain had established new neural connections and things clicked. I read several books and watched lots of people writing haskell and explaining the new (to me) concepts on twitch and youtube.

[+] bramhaag|1 year ago|reply
Haskell Programming from First Principles[1] is extremely comprehensive, covering everything from lambda calculus to IO.

For further self-learning, it might be interesting to learn about the underlying mathematical concepts, such as category theory. A deep dive into the workings of a Hindley–Milner type system might also help demystify some of Haskell's typing magic.

[1] https://haskellbook.com/

[+] wavemode|1 year ago|reply
I can only speak about my personal experience.

When I was in college I read through Haskell Programming From First Principles. My prior programming experience (of probably ~10ish years, as a hobbyist) was mostly C++, Java and PHP.

I found it grueling. I really was just not used to reading definitions like

  newtype State s a = State { runState :: s -> (a, s) }
  instance Monad (State s) where
      return x = State $ \s -> (x,s)
      (State h) >>= f = State $ \s -> let (a, newState) = h s
                                          (State g) = f a
                                      in  g newState
Nowadays, such a definition (and its practical applications) seems very trivial, but at the time I remember it felt like learning a new type of math, or a new language. Most of my time reading that book was spent struggling to figure out how the types fit together and why they were useful and/or necessary to be structured the way they were.

This wasn't the book's fault - I actually think the book does go to great lengths to try to guide the reader gradually toward understanding. My brain just wasn't ready for it. It took a long time of playing around with Haskell, as well as playing around with other languages (and seeing things like async-await and thinking to myself "hey! that's a monad!") before these things became second nature. I think it just goes to the concept of "osmosis" in psychology - sometimes you subconsciously absorb information over time before it starts to make sense.

Dunno if this comment constitutes "advice" per se, lol. Just offering you something to relate to, I guess.

[+] codethief|1 year ago|reply
I recently started reading Bartosz Milewski's Category Theory for Programmers[0] and while it's less about Haskell per se and more about the ideas behind it, I found it did a much better job at explaining Haskell to me than any other introduction I read before. At least I'm able to appreciate Typing the Technical Interview[1] now. :-)

[0]: https://github.com/hmemcpy/milewski-ctfp-pdf

[1]: https://aphyr.com/posts/342-typing-the-technical-interview

[+] goostavos|1 year ago|reply
This is a good source if you feel like waiting until chapter 14 for "so, anyways, that's how addition works." I know Haskell pretty well and I've bounced off Milewski's stuff multiple times.

Haskell != Category Theory. You don't have to know what an Endofunctor is in order to write useful programs. Haskell is just another programming language. It's totally possible to do cool stuff in it without knowing any of the theories that back a lot of the "why" behind its common abstractions.

Pick up any book and just start building toy programs! Don't over think it. Start very small. Make a CLI tool. Scrape some data off the internet. Even simple haskell programs will cause you to bump into all kinds of concepts at the time you need to learn them.

Just working through a book can make Haskell seem painfully esoteric. Monad transformers broke my brain when I tried to learn them simply because I reached the monad transformer chapter. However, I finally "got" them once I was actually building something, because their existence is something you naturally start to bump into the more you program. There's a friction that comes from no having them, but noticing that "friction" and letting it guide you can only happen over time as you use the language.

[+] graphov|1 year ago|reply
I'd recommend Well-Typed's YouTube channel: https://www.youtube.com/@well-typed

Andres Loeh has recently released a pretty comprehensive introductory series there and in addition they have a fortnightly stream "The Haskell Unfolder" where they go over some more advanced subjects with examples.

[+] mhitza|1 year ago|reply
I think Learn you a Haskell is a good introduction, but you will learn more by doing.

I don't know what state of the art is nowadays for learning Haskell, I started my journey more than 10 years ago, but for help I recommend https://discourse.haskell.org/ whenever you feel stuck, have questions; instead of SO/subreddit.

edit: while Copilot, or equivalent, will hallucinate APIs that don't exist, I recommend having such a thing enabled as it will help you with syntax / standard library functions early on.

Also take a good look at the base, containers, directory, filepath, etc packages documentation. These come as part of the standard installation (with something like ghcup), and represent the "standard library" you have access to (on paper that would be only limited to base). For a full list of installed packages you can always run `ghc-pkg list` and start browsing the generated documentation on hackage.haskell.org

[+] Strix97|1 year ago|reply
Hi I am seeing a lot of good resources in this thread already but I might have something to add. I am also learning Haskell at the moment, and the thing that really helped me push through it was this MOOC (Massive Open Online Course) by the university of Helsinki which is completely free and online available.

https://haskell.mooc.fi/

It's a structured, has a lot of excercises and so far (I am on Lecture 5 at the moment) very clear. It wont make you an expert, but will get you writing code quickly.