1. 27

  2. 10

    It’s nice to hear stuff like this. I recently realized that my own path to learning Haskell (entirely self taught) began over 10 years ago! It turned out that the last year or two have been the most phenomenally productive in terms of learning (I really dug down into reading papers, books, and sharpening my algebra tremendously) but it’s been a slow process of shaping my mind. I read old code now and suddenly remember the challenges and difficulties I’d forgotten I ever faced.

    This shouldn’t be discouraging to anyone else, though. It was just my own path, and it’s interesting to reflect on the slow growth of a skill.

    1. 8

      A lot of people have war stories about learning Haskell and it’s not obvious but a lot of the more vocal members of the community have been honing their craft for a decade or more. It’s gotten easier in the last couple of years but there is still an enormous number of things to learn to get up to speed with Modern Haskell and navigating it on your own is an endurance test.

      1. 7

        Took me about 5 years to get anywhere with Haskell. Now I can bootstrap a programmer with zero FP experience (if pairing) in a couple weeks, or if we’re daytripping it on the weekend, a few months.

        Most people I’ve taught Haskell are teaching people that are learning even faster. There’s this weird pedagogical-pyramid-of-acceleration happening because people are learning how to teach Haskell better and better.

        This has been happening quickly. I’m quite excited.

        1. 7

          This will be very unpopular, but I think Haskell is over rated, and I don’t think it’s really worth it to spend all this time learning it.

          I spent a while trying to “get” Haskell, and I even learned enough to write some non-trivial (albeit small) programs in it. At the end of the day I always felt I spent the majority of my time working around the language and jumping through its hoops, rather than solving my problems.

          I find I’m incredibly more productive in languages like Lisp and Python because they get out of my way and do what I want.

          Maybe it works for some people, but I think it’s important to point out that it’s not for everybody.

          1. 5

            Was it lack of experience with Haskell which slowed you down or flaws with the language?

            1. 2

              I’m not sure if I would characterize it as a lack of experience with Haskell or an impedance mismatch between the way it works and the way I think. It’s easy to spin this as I’ve given up and I’m not smart enough for Haskell, or I’m not trying hard enough, or whatever, but I think it’s a problem a lot of people have, as evidenced by this article.

              Further, I’m not sure it’s worth it. Nobody writes articles about how it’s taken them years to learn Python, Java, or Lisp.

              1. 3

                I’m not sure your last statement is true. I think an interesting, if totally hypothetical, situation would arise should someone be taught to program exclusively using languages like Haskell/Agda/Coq and then take on the task of learning Python.

                I wouldn’t wager that it’ll take the same kind of investment, but I think it’d be closer to comparing apples and apples that way.

            2. 1

              I’m curious what you didn’t like, specifically.

              TBH, I don’t know of any languages that require quite as much spin-up time. I don’t worry about how long it takes because I’m partially into it for the sheer amount of nifty ideas it encompasses that I can shamelessly pilfer for future languages of mine. But, also, to continue my learning.

              1. 3

                Immutable data structures are awkward to work with. They might eliminate some classes of errors, but I felt they slowed me down so much that it’d probably be faster to just debug mutable data structures.

                And debugging Haskell was difficult. Debug.Trace helps, but it’s much easier with a standard debugger, like gdb or Python’s pdb.

                I often got the impression people using Haskell were over thinking everything and making it far more complicated than it needed to be. The worst example I remember turned a 15 line shell script into ~45 lines of Haskell. Yes, the Haskell code is very elegant and clever, but what is it achieving over the shell script or a 10 line Python script?

                I have to admit the last time I used it was a few years ago, and all of my biggest complaints could have resolved themselves since then, so maybe I’ll give it another try.

                1. 1

                  GHCi has a “standard debugger” with a lot of features (some not possible in other environment). It’s probably not very well known because not many people use it:


            3. 6

              Good post :) I’ve been learning going on 3 years. I started with the 99 Haskell problems, LYAH and RWH. I think the biggest help I’ve had so far has been getting on irc.freenode.net’s #haskell, #haskell-game and #haskell-beginners. Actually being able to talk to someone helps a lot. Thanks guys!

              1. 4

                This jives with my experience. I was experienced in a handful of mainstream imperative languages, and I it took around 6 years of on-again-off-again putzing around for me to reach an intermediate level where I’m comfortable writing Haskell code that does state, IO, and pure stuff “properly” segregated. I still get stymied by complicated type signatures, but just as often, the signatures help me figure out what to do next.

                There are certainly better resources today, but the core conceptual challenges would still be hard if I had to start learning Haskell today from zero.