Popularizing Haskell through easy web deployment
blog.begriffs.com
blog.begriffs.com
It's a new company focusing on this exact problem. They offer tools like an IDE and deployment model. You can just sign-up on their website and start coding directly, you don't need to mess with setting things up. They also got School of Haskell which is a central place of really great tutorials ranging from tutorials on developing web apps to category theory stuff.
Check them out: https://www.fpcomplete.com/
There may be some benefits of using whatever FP Complete offers, but if anyone is struggling with getting Haskell set up on his computer with the official releases, then that person might need to acquire some other skills first before delving into the world of pure functional programming.
Of all the benefits I've heard ever used to sell IDEs, that's got to be the least common. Usually, things like syntax highlighting and error detection as you type, project management tools, version control integration, autocomplete, documentation/API tooltips, debugger integration, etc. are the advantages.
Some of those might be less relevant to Haskell than to, say, Java/C# style languages, but some of them would still be useful.
Syntax highlighting is part of any editor that is aimed at programmers, the interpreter does a great job highlighting errors, version control is done with git, and there is plethora of documentation on Haskell available too. Normally, ghci satisfies that need as well.
The fact is, you CAN do many of the things an IDE can do without one; its just generally harder, less discoverable, slower, takes longer to master, and for no real benefits. I would rather have a text box pop up saying exactly what types something has, and all the documentation about those types, and where it is defined in code, directly within my code in 0.1 seconds, then have to go and run some grep or hoogle search or whatever.
Code completion, syntax checking, looking up documentation, setting up projects and makefiles, code re-factoring, etc... Granted, Emacs and VIM will do most of this, and the language's tools will do the rest, but some people like having everything in one convenient package...
What makes one think that any language can prevent "a jumbled undocumented mess"?
Type systems are self-documenting? (Or, Hindley-Milner type systems are self-documenting?)
Disclaimer: Didn't write read a lot of Haskell so it may be just that.
It's also a familiarity thing. The most complex signatures require some practice before they're easy to digest.
The avoidance of variable names is hard to judge until you program in Haskell a lot. Variables (or "points") tend to just be used to wire pipes together. These variables are rarely used more than a line or two after their definition and thus short names emphasize this local context.
When people write code that involves variables naming mutable cells or long-lived context they provide long, descriptive names. I don't think anyone disagrees about the utility of that. It's just a rare style in Haskell.
[1] http://ttic.uchicago.edu/~dreyer/course/papers/wadler.pdf [2] http://ocharles.org.uk/blog/pages/2013-12-01-24-days-of-hack...
mod_buildpack?
Maybe I'll revisit it one day, but that was my pain point...
Wait, what?
http://stackoverflow.com/questions/15236238/current-state-of...
And here is the GHC (Haskell compiler) docs on controlling the garbage collector:
http://www.haskell.org/ghc/docs/7.0.1/html/users_guide/runti...
If you want to popularize Haskell you'll need to rework the syntax at the very least.
Edit: This is FUD and I kind of feel offended by it, though I'm not sure that is rational
I'm not a math major. I am a web dev. I want to use Haskell (and am using in a smaller capacity) because it means I have to be up late fixing things less. It means that I can worry about my sites getting hacked less because of the strong static typing guarantees which protect me against csrf.
On top of all that type annotations are great for documenting things. On top of that, composing functions and monads can allow you to do things much safer and much more quickly.
There are many teaching resources which show how some of Haskell's perceived cons can be pros such as these:
http://yannesposito.com/Scratch/en/blog/Haskell-the-Hard-Way...
http://book.realworldhaskell.org/
http://adit.io/posts/2013-04-17-functors,_applicatives,_and_... (with web dev applicable example) http://en.wikibooks.org/wiki/Write_Yourself_a_Scheme_in_48_H...
Honestly from my experiences in #haskell on freenode, /r/haskell, and Haskell related content on the web it seems like many more people are using it with the intent to make "real world software".
I haven't gotten the ivory tower vibe from anyone in the Haskell community yet. Quite the opposite actually, everyone seems very pragmatic.
I.e., if I want a module in my app to have two different types containing an element 'customerID' that I'd like to refer by name in that context, then it's a bit painful - and it is a really common need if I need to quickly make a mostly-CRUD webapp, for which otherwise Haskell/Yesod would be as practical as Ruby/Rails.
http://www.reddit.com/r/haskell/comments/1rpte3/explanation_...
The other thing is I believe frameworks like Yesod use property based testing which IME catches a lot more than unit tests by themselves.
I feel like my point is unclear here, perhaps someone more experienced with Haskell and/or Yesod can articulate it better than I can.
Most web devs are frightened by functional programming idioms and will run away screaming when exposed to monads.
But the biggest problem imho is the type system that while great, makes things like making simple structs / named tupples or whatever you want to call them annoying and the lack of any "nice" way to just do OOP in it - and no, saying OOP is a bad idea and pretending it doesn't exist doesn't work.
Scala is a good Haskell for web dev. But it's too complex and has no chance of broad adoption against Node/Javascript, Ruby, Python and even PHP frameworks because for 90% of devs it simply doesn't bring anything good enough to make it worth putting up with the complexities stemming from the unholy OOP+FP mix.
Scala's type signatures are even harder than Haskell's (or at least, mixing FP with OOP makes them harder for me) but you don't get the same guarantees about side-effects and the type inference doesn't work as well. And implicits scare me.
Scala's OOP may be good or bad, but it certainly adds an additional layer of complexity, and one you can't ignore when reading or using someone else's code.