5 ms·

This is kind of the problem, though: Haskell is popular among people for whom "write Scheme in this language" is an example of a practical introduction. It freq

by djur 12y ago

This is kind of the problem, though: Haskell is popular among people for whom "write Scheme in this language" is an example of a practical introduction. It frequently seems like a community of PLT experts talking with PLT apprentices, with the workaday concerns of 95% of practicing developers treated as an exercise to figure out on your own time. This isn't a criticism of Haskell or Haskellers. It's more an observation that the current makeup of the Haskell community might prove to be a drag on its appeal.

kasbah 12y ago
I guess so. I got a bit fed up with parsing text too and got side-tracked to more graphical things. Initially to Elm [1]. It's not exactly Haskell but Elm is a fun way to get into Functional and Functional Reactive programming while drawing some things on screen and making them move. There are probably more graphical tutorials for Haskell too. I recently found some good examples for Gloss [2] and am moving from Elm to that right now. There is an "Elm for Haskell" called HElm [3] too. [1]: http://elm-lang.org http://elm-lang.org [2]: http://gloss.ouroborus.net http://gloss.ouroborus.net [3]: http://helm-engine.org http://helm-engine.org
coolsunglasses 12y ago
I teach a lot of Haskell [1] and observe a lot of people teaching Haskell. Write Yourself a Scheme is not representative of how the Haskell community teaches Haskell. I can't even remember the last time it was cold-suggested to somebody. The last person I knew to do so, did so knowing they were going about it the "hard way". They also did it with the intent of actively upgrading/updating the code WYASI48H as they went into a more modern style. They gave a talk on it after. It's a good way to firm up your knowledge if it's the sort of project that interests you, but needs love and isn't a good introduction for most. [1]: https://github.com/bitemyapp/learnhaskell https://github.com/bitemyapp/learnhaskell
- djur 12y ago
  The course you recommend (it's good, I've read it) involves writing parsers and some bits of Risk; the follow-up includes another university course, LYAH, and RWH. You also have a lot of good resources for Cabal and for development environments. That's appreciated. But a lot of developers' bread and butter is "this data is here; I need to grab it from this place, make appropriate changes to it, and put it in this other place." They might use an HTTP client and a JSON parser for it, or FTP and an image processing library, a database or two, etc. Unless I'm mistaken, the first place new Haskellers would run into the first inkling of that kind of stuff would be in chapter 5 of RWH, which you describe as a "thick book" and a "reference". The first appearance of a database is in chapter 20. This is stuff that you can find about PHP, Ruby, Python, etc. by drooling into the keyboard while Google is open. It is comparatively _exceptionally_ hard to find the same kind of nuts-and-bolts material about Haskell.
  - josephlord 12y ago
    I think this is an interesting point and it seems to me there are two distinct learning styles. Bottom up learning where you start from the basic features of the language and theoretical foundations of computers (or the practical foundations for C and assembly) and a top down approach where you start with rich frameworks and bolting together code that you don't understand. I think the different approaches lead to a different environment in terms of libraries available and the types of learning guides available.
    - minikomi 12y ago
      There's definitely a stage when you want to graduate from bottom-up tinkering & learning the underlying concepts to making things -- this is where I feel there's a big gap in the haskell materials right now. There's some great screncasts though which have been helpful. https://www.youtube.com/watch?v=0I90MTip-OQ https://www.youtube.com/watch?v=0I90MTip-OQ - Implement a sed clone in Haskell (a bit broken towards the end but a great look at a small incremental project) https://www.youtube.com/watch?v=zZ_nI9E9g0I https://www.youtube.com/watch?v=zZ_nI9E9g0I - implementing redo in Haskell
      - josephlord 12y ago
        Of course those starting at the bolting together of significant blobs may learn their way down to the more fundamental levels too as they start to dig into the libraries that they use and even down into the languages. I don't take a particular view on which is the better way. The distance from the fundamentals up to something superficially impressive seems a very long way to me. So I think probably the realistic approach for most will be to start of the bolt things together and then discover a desire to understand the fundamentals. I think to start at the fundamentals end needs a lot of patience but it probably suits those intolerant of magic.
        innguest 12y ago
        I think to start at the fundamentals end needs a lot of patience but it probably suits those intolerant of magic. Very well said; I'm one of those people and that's what drove me from Ruby to Haskell - Ruby and its frameworks are all very magical and don't seem to hinge on any common foundation other than the intricate details of Ruby's object model, which is not a satisfactory set of principles, but an arbitrary set of rules. On the other hand, while Haskell is several times harder for it, it does eventually quench the thirst to connect every new thing I learn with the foundational things I already know (and which are in fact a set of simple rules - lambda calculus).
- deleted 12y ago
  [deleted]
mbrock 12y ago
While I agree that this is a problem in some sense, I also think it's a rather natural consequence of the primary strengths of Haskell: its focus on mathematical abstraction; its rational & precise language theory; and its willingness to impose a learning curve and do things differently. The Haskell community has an inofficial motto that reads "avoid success at all costs," from an old presentation by Simon Peyton-Jones. The correct interpretation is "avoid (success at all costs)," that is, don't make decisions for "populistic" reasons, and don't be afraid to take the "high road." Of course, it would be amazing to see much more "practically" oriented teaching material, because as you say there's quite a bit you just have to figure out. But I don't think Haskell is uniquely bad at this. It's just bad in different ways... Documentation for dynamically typed, "pragmatic" things – like jQuery, many Node libraries, etc – often confuses and annoys me, because I'm so used to Haskell's type specifications and clear abstractions. Granted, I've been coding Haskell for years, and went to a university that uses it as the primary language for students, but I think Haskell libraries are often very clear and easy to use. Haskell also has truly excellent frameworks and libraries for things like concurrency and parallellism. Simon Marlow's book is exemplary and wonderful; it should qualify as a very good resource for practicing developers. Yet another point: GHC's type errors can seem obscure for a beginner, and sometimes they're indeed very tricky, but largely, the compiler actually provides loads of helpful information in a clear and well-presented way (searching for contextual info, spell checking, etc). I can't properly express how much I prefer fixing GHC type errors over debugging JavaScript type errors... Honestly, I think the state of teaching programming is not great in general. I remember the Java courses at university... Learning how to use Swing, UML diagrams, sockets... It's kind of a nightmare. But regardless of all of this, it's evident that more and more people are attracted to using Haskell for "real-world" systems, and I believe that Haskell's incubation period as an academic language was utterly crucial to its maturation as a novel and strong technology. (I'm not accusing you of this by any means, but sometimes there's an anti-academic tone in criticisms of Haskell, which I think is completely misguided and frankly dangerous.)
- djur 12y ago
  Regarding the anti-academic tone: I hear you, but you know what they say about converts being the greatest fanatics? There's a certain loud category of people who have relatively recently achieved illumination with Haskell but have very little of use to tell anyone else about it. Conversations with this type tend to go along the lines of "Haskell is the best"/"Why"/"Static typing, lazy evaluation, purity"/"Why are those good things"/"derisive snort". Usually "blub" gets tossed in there for good measure. Agreed on the generally dismal state of programming education. Usually I'm pretty glad I didn't go to college -- those four years were better spent working on real projects with smart people. But I have been trying to backfill the interesting and useful academic material as I go.

by djur 12y ago

kasbah 12y ago

I guess so. I got a bit fed up with parsing text too and got side-tracked to more graphical things. Initially to Elm [1]. It's not exactly Haskell but Elm is a fun way to get into Functional and Functional Reactive programming while drawing some things on screen and making them move. There are probably more graphical tutorials for Haskell too. I recently found some good examples for Gloss [2] and am moving from Elm to that right now. There is an "Elm for Haskell" called HElm [3] too. [1]: http://elm-lang.org http://elm-lang.org [2]: http://gloss.ouroborus.net http://gloss.ouroborus.net [3]: http://helm-engine.org http://helm-engine.org

coolsunglasses 12y ago

I teach a lot of Haskell [1] and observe a lot of people teaching Haskell. Write Yourself a Scheme is not representative of how the Haskell community teaches Haskell. I can't even remember the last time it was cold-suggested to somebody. The last person I knew to do so, did so knowing they were going about it the "hard way". They also did it with the intent of actively upgrading/updating the code WYASI48H as they went into a more modern style. They gave a talk on it after. It's a good way to firm up your knowledge if it's the sort of project that interests you, but needs love and isn't a good introduction for most. [1]: https://github.com/bitemyapp/learnhaskell https://github.com/bitemyapp/learnhaskell

djur 12y ago
The course you recommend (it's good, I've read it) involves writing parsers and some bits of Risk; the follow-up includes another university course, LYAH, and RWH. You also have a lot of good resources for Cabal and for development environments. That's appreciated. But a lot of developers' bread and butter is "this data is here; I need to grab it from this place, make appropriate changes to it, and put it in this other place." They might use an HTTP client and a JSON parser for it, or FTP and an image processing library, a database or two, etc. Unless I'm mistaken, the first place new Haskellers would run into the first inkling of that kind of stuff would be in chapter 5 of RWH, which you describe as a "thick book" and a "reference". The first appearance of a database is in chapter 20. This is stuff that you can find about PHP, Ruby, Python, etc. by drooling into the keyboard while Google is open. It is comparatively _exceptionally_ hard to find the same kind of nuts-and-bolts material about Haskell.
- josephlord 12y ago
  I think this is an interesting point and it seems to me there are two distinct learning styles. Bottom up learning where you start from the basic features of the language and theoretical foundations of computers (or the practical foundations for C and assembly) and a top down approach where you start with rich frameworks and bolting together code that you don't understand. I think the different approaches lead to a different environment in terms of libraries available and the types of learning guides available.
  - minikomi 12y ago
    There's definitely a stage when you want to graduate from bottom-up tinkering & learning the underlying concepts to making things -- this is where I feel there's a big gap in the haskell materials right now. There's some great screncasts though which have been helpful. https://www.youtube.com/watch?v=0I90MTip-OQ https://www.youtube.com/watch?v=0I90MTip-OQ - Implement a sed clone in Haskell (a bit broken towards the end but a great look at a small incremental project) https://www.youtube.com/watch?v=zZ_nI9E9g0I https://www.youtube.com/watch?v=zZ_nI9E9g0I - implementing redo in Haskell
    - josephlord 12y ago
      Of course those starting at the bolting together of significant blobs may learn their way down to the more fundamental levels too as they start to dig into the libraries that they use and even down into the languages. I don't take a particular view on which is the better way. The distance from the fundamentals up to something superficially impressive seems a very long way to me. So I think probably the realistic approach for most will be to start of the bolt things together and then discover a desire to understand the fundamentals. I think to start at the fundamentals end needs a lot of patience but it probably suits those intolerant of magic.
      - innguest 12y ago
        I think to start at the fundamentals end needs a lot of patience but it probably suits those intolerant of magic. Very well said; I'm one of those people and that's what drove me from Ruby to Haskell - Ruby and its frameworks are all very magical and don't seem to hinge on any common foundation other than the intricate details of Ruby's object model, which is not a satisfactory set of principles, but an arbitrary set of rules. On the other hand, while Haskell is several times harder for it, it does eventually quench the thirst to connect every new thing I learn with the foundational things I already know (and which are in fact a set of simple rules - lambda calculus).
deleted 12y ago
[deleted]

mbrock 12y ago

While I agree that this is a problem in some sense, I also think it's a rather natural consequence of the primary strengths of Haskell: its focus on mathematical abstraction; its rational & precise language theory; and its willingness to impose a learning curve and do things differently. The Haskell community has an inofficial motto that reads "avoid success at all costs," from an old presentation by Simon Peyton-Jones. The correct interpretation is "avoid (success at all costs)," that is, don't make decisions for "populistic" reasons, and don't be afraid to take the "high road." Of course, it would be amazing to see much more "practically" oriented teaching material, because as you say there's quite a bit you just have to figure out. But I don't think Haskell is uniquely bad at this. It's just bad in different ways... Documentation for dynamically typed, "pragmatic" things – like jQuery, many Node libraries, etc – often confuses and annoys me, because I'm so used to Haskell's type specifications and clear abstractions. Granted, I've been coding Haskell for years, and went to a university that uses it as the primary language for students, but I think Haskell libraries are often very clear and easy to use. Haskell also has truly excellent frameworks and libraries for things like concurrency and parallellism. Simon Marlow's book is exemplary and wonderful; it should qualify as a very good resource for practicing developers. Yet another point: GHC's type errors can seem obscure for a beginner, and sometimes they're indeed very tricky, but largely, the compiler actually provides loads of helpful information in a clear and well-presented way (searching for contextual info, spell checking, etc). I can't properly express how much I prefer fixing GHC type errors over debugging JavaScript type errors... Honestly, I think the state of teaching programming is not great in general. I remember the Java courses at university... Learning how to use Swing, UML diagrams, sockets... It's kind of a nightmare. But regardless of all of this, it's evident that more and more people are attracted to using Haskell for "real-world" systems, and I believe that Haskell's incubation period as an academic language was utterly crucial to its maturation as a novel and strong technology. (I'm not accusing you of this by any means, but sometimes there's an anti-academic tone in criticisms of Haskell, which I think is completely misguided and frankly dangerous.)

djur 12y ago
Regarding the anti-academic tone: I hear you, but you know what they say about converts being the greatest fanatics? There's a certain loud category of people who have relatively recently achieved illumination with Haskell but have very little of use to tell anyone else about it. Conversations with this type tend to go along the lines of "Haskell is the best"/"Why"/"Static typing, lazy evaluation, purity"/"Why are those good things"/"derisive snort". Usually "blub" gets tossed in there for good measure. Agreed on the generally dismal state of programming education. Usually I'm pretty glad I didn't go to college -- those four years were better spent working on real projects with smart people. But I have been trying to backfill the interesting and useful academic material as I go.