[HN Gopher] Ask HN: What resources do you recommend for learning...
___________________________________________________________________
Ask HN: What resources do you recommend for learning Haskell?
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.
Author : hackerthemonkey
Score : 57 points
Date : 2024-07-21 18:57 UTC (4 hours ago)
| lambdaba wrote:
| Not meaning to hijack the thread, but I would be interested in
| opinions on the "best" type system implementation that has enough
| of a library ecosystem to be suitable for web/app development.
|
| To be clear it's also for learning, but I'm wondering what else
| is there outside of the Haskell/PureScript etc. world.
| bramhaag wrote:
| Haskell is perfectly suitable for web dev, and has a great
| ecosystem for it.
|
| Servant[1] allows you to create type-safe APIs, and there are
| many libraries that allow you to define your HTML in a type-
| safe way.
|
| The Haskell wiki lists some other frameworks:
| https://wiki.haskell.org/Web/Frameworks
|
| [1] https://hackage.haskell.org/package/servant
| yoyohello13 wrote:
| 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 wrote:
| 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.
| hiAndrewQuinn wrote:
| +1 for HPFFP. The 1200 page behemoth that finally made
| everything, and I mean everything, click.
| John23832 wrote:
| "Real World Haskell"
| ks2048 wrote:
| Graham Hutton YouTube series:
|
| Functional Programming in Haskell
| https://youtube.com/playlist?list=PLF1Z-APd9zK7usPMx3LGMZEHr...
| bramhaag wrote:
| 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/
| matt-noonan wrote:
| 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.
| aranchelk wrote:
| I started by reading those two, then made it through a chunk of
| 99 problems in Haskell -- at some point I lost interest and
| felt ready to write applications.
|
| https://wiki.haskell.org/H-99:_Ninety-Nine_Haskell_Problems
|
| I liked Haskell Programming from First Principles as well --
| read it later on to fill in some gaps.
| graemep wrote:
| Graham Hutton's lectures (on Youtube) seem pretty good. He also
| has written a book. Both seem pretty good but not got very far
| yet myself.
| tombert wrote:
| 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.
| johnkelly wrote:
| I really like this new YouTube series Haskell For Dilettantes
|
| https://m.youtube.com/watch?v=nlTJU8wLo7E
| codethief wrote:
| 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 wrote:
| 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.
| makerofthings wrote:
| I did https://learnyouahaskell.com and then
| https://adventofcode.com . I've been learning Haskell for about 6
| years now and I sort of get it.
| wrsh07 wrote:
| If you're familiar with functional programming, I really like the
| learnxinyminutes reference for Haskell:
| https://learnxinyminutes.com/docs/haskell/
|
| I'm not sure why, but the Haskell one clicks for me more than
| some of their other guides.
|
| This isn't a great way to learn Haskell, but it's enough to start
| writing working code (and writing working code is a good way to
| learn!!)
| wrsh07 wrote:
| Ooh, one nice book is the Okasaki purely functional data
| structures. The inline code is not Haskell, but iirc the
| appendix has Haskell implementations
| karambit wrote:
| Since no one has mentioned this yet, https://haskell.mooc.fi
| nvarsj wrote:
| 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 wrote:
| It's also my favorite beginners resource. And free.
|
| Straightforward and short. Takes you to the interesting bits
| very quickly.
| rnallandigal wrote:
| "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 wrote:
| 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.
| anfelor wrote:
| 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 :)
| TwentyPosts wrote:
| ...what are lenses? Never heard of those.
| turboponyy wrote:
| As with anything Haskell, one could simply reply with "here's
| the formal definition."
|
| But in easily digestible terms, it's a way to narrow your
| view over a collection to a subset that satisfies some
| property, and perhaps perform some operations on that subset.
|
| This video presentation (with a very humorous audience
| dynamic, might I add) serves as a great introduction by
| example: https://youtube.com/watch?v=QZy4Yml3LTY
| tmountain wrote:
| I like this advice, but I would suggest adopting a prelude that
| has better defaults than what the language ships with.
| edude03 wrote:
| Is there one you'd recommend?
| rank0 wrote:
| What is the appeal of haskell? Genuinely curious
| exe34 wrote:
| pure functional. no mutations. (state and i/o handled with
| inscrutable magic).
|
| basically every code base out there could use more functional
| effort - simple data structures and simple functions that
| operate on these to return a brand new structure.
| shae wrote:
| Easy to fix work code in the middle of the night when pagerduty
| hits
| mrkeen wrote:
| Before Haskell I felt like I was cargo-culting advice - "use
| private fields with getters & setters", "everything should have
| an interface", "avoid static methods", "avoid 'new' and use
| factories instead". I figured eventually one of these days
| these things would click.
|
| With Haskell came new principles which had immediately obvious
| value - "is your function well-defined over all possible
| inputs?" and "does it always produce the same output given the
| same input?".
|
| I later 'got' that first set of principles, but I mostly
| disagree with them.
|
| My day job has always involved looking at exceptions and logs,
| figuring out "how something went wrong", and then trying to fix
| it. Guess which set of principles helps me make software that
| typically "just works".
| kryptiskt wrote:
| It takes an idea[0] and runs with it as far as it goes. The
| best part is that when they got to obstacles like handling of
| IO, they didn't take the easy route and compromise the vision
| in favor of a pragmatic solution. Instead they went into
| unexplored territory and came back with monads, which proved an
| extremely fertile ground for more than IO.
|
| Obviously, Haskell being an academic language helps here, since
| novel ideas lead to papers and boring old ideas don't.
|
| [0]: That is statically typed lazy functional programming.
| exe34 wrote:
| never learnt it myself, but if I ever tried again, I'd work my
| way through this: https://wiki.haskell.org/Typeclassopedia
| brudgers wrote:
| Time. Learn a little Haskell this month. Learn a little Haskell
| in December. Some more over the next few years. In between you
| will be learning more about programming in general and many other
| things including how you learn.
|
| There's no midterm in eight weeks; no final grade after that, and
| nobody who matters cares how good or bad you are at Haskell. Like
| most things, it's not worth having an opinion about.
|
| Give yourself permission to write Haskell poorly because that
| makes it more likely you will write Haskell. Give yourself
| permission to not learn Haskell because maybe you like the idea
| of writing Haskell more than the work of learning Haskell...
|
| ...yep, time and permission are the best resources for learning
| Haskell (or anything else as an adult). It really doesn't matter
| what book you pick. Either you enjoy committing or you don't.
| Either the work feels satisfying while doing the work or doesn't.
|
| When the work is truly satisfying, it doesn't need to be
| optimized against imagined external opinions. You just do it
| because it is what you do.
|
| Or not. Good luck.
| Zhyl wrote:
| I found these two videos on combinators and lambda calculus
| recently. They're only tangentially related to Haskell, but they
| are the most approachable videos on the topic I have ever seen.
|
| https://www.youtube.com/watch?v=3VQ382QG-y4
|
| https://www.youtube.com/watch?v=pAnLQ9jwN-E
| francogt wrote:
| 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/
| robertinom wrote:
| This is a great up to date course to get you started:
| https://youtube.com/playlist?list=PLNEK_Ejlx3x1D9Vq5kqeC3ZDE...
| mhitza wrote:
| 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
| 3D39739091 wrote:
| https://www.manning.com/books/get-programming-with-haskell
|
| Get Programming With Haskell by Will Kurt. Made up of small
| lessons that all build on top of each other and will really help
| you understand what's going on.
|
| I wanted to like Effective Haskell but honestly didn't. YMMV.
| viking66 wrote:
| 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.
| carterschonwald wrote:
| It's just a programming language. Write something and fail and
| ask for feedback and help when stuck.
|
| Source: I've been using Haskell for fun and profit on and off
| since 2004
| tiberius_p wrote:
| Real World Haskell was pretty good last time I read it. It has
| lots of concrete code examples that you can use in real world
| applications. It won't bore you to death with abstract theory and
| instead it will blend it with real world problems and make
| learning both fun and useful at the same time.
| 2-3-7-43-1807 wrote:
| aren't there like dozens of AskHNs about that question already?
| wavemode wrote:
| 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.
| graphov wrote:
| 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.
___________________________________________________________________
(page generated 2024-07-21 23:13 UTC)