
Popularizing Haskell through easy web deployment  - tikhonj
http://blog.begriffs.com/2013/12/popularizing-haskell-through-easy-web.html
======
klrr
Since no one have pointed out yet, I take the opportunity to recommend
FPComplete.

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/](https://www.fpcomplete.com/)

~~~
gu
I don't get the appeal of an IDE in Haskell development. You can download the
Haskell platform on haskell.org. In the case of Windows or OS X, it takes a
few mouse clicks, and on Linux you launch a package manager to install it.

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.

~~~
dragonwriter
Your post implies that the main reason people would use an IDE is because they
are having trouble getting non-IDE tools for the language setup.

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.

~~~
gu
My impression is certainly that IDEs are aimed at beginners and users of more
'complex' languages like Java. (Case in point: Java has DrJava and other
beginner IDEs, as well as IDEs for professionals like IntelliJ.)Indeed, I was
referring to the the claim of the OP that "you don't need to mess with setting
things up", which, to me, seemed to imply that it was a significant hurdle to
get started with Haskell using an editor and ghci.

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.

~~~
dustingetz
I write scala in an IDE and I am not a beginner

~~~
gu
Scala is arguably part of the group of 'complex' languages I mentioned.
Besides, the Scala worksheet functionality in Eclipse is really neat, which is
another reason to consider using an IDE for it.

------
nnq
> nicely structured codebases whose language helped prevent a jumbled
> undocumented mess

What makes one think that _any_ language can prevent "a jumbled undocumented
mess"?

~~~
acchow
It sounds like a thinly-veiled quip against duck typing.

Type systems are self-documenting? (Or, Hindley-Milner type systems are self-
documenting?)

~~~
tel
Oh yes! My _favorite_ part of Haskell's type system is it's documentation
purpose. It doesn't cover intent very well, but it's quite frequent that I can
reason about the entire purpose and functionality of a function just by
looking at its type. This documentation is guaranteed to never go out of date.

~~~
miloshadzic
I feel that while type information is useful, some of the more advanced
libraries have signatures that are very difficult to reason about.

Disclaimer: Didn't write read a lot of Haskell so it may be just that.

~~~
tel
Definitely. It can go VERY overboard at times, and that's part of Haskell
style, writing code that makes intelligible types appear. It means that both
the compiler and your users will have an easy time with your code. Most of the
best libraries are pretty good about that.

It's also a familiarity thing. The most complex signatures require some
practice before they're easy to digest.

------
regularfry
What gave PHP its boost was a pervasive mod_php, and an instant change-
file/see-change cycle.

mod_buildpack?

~~~
klrr
Not sure if it's related (not a web developer), but here it is anyway:
[http://nixos.org/~eelco/mod_haskell/](http://nixos.org/~eelco/mod_haskell/)

------
Mikeb85
For me, the biggest issue to learning Haskell is once programs progressed to a
certain level of complexity, the sheer amount of types that got thrown at me
made my head hurt. I could deal with pure functions, IO, monads (I even like
monads), even mutable variables and arrays weren't too bad. But the types, so
many types and types of types... It seemed every value that was meant to
represent anything had its own type and reasoning about what function to use
on what type was too much.

Maybe I'll revisit it one day, but that was my pain point...

~~~
Ixiaus
The more software you write in it the more that stuff becomes second nature
(unless you're a library writer in which you have to reason about your types
very carefully).

------
mbq
Two, well, issues from my experience with gitit (great software by the way):
compilation may take huge amounts of RAM compared to what the webapp itself
will later use -- it is likely that one will need to use some other, metal
machine for building. Also, Haskell is doing idle garbage collection which
eats CPU even when nothing is happening, and this may become a less or more
painful surprise. It can be turned off, though.

~~~
jcurbo
I don't have any specific info about what the parent post was talking about,
but for those that were curious about Haskell's garbage collector in general
(like me), here is a Stack Overflow link with some explanation:

[http://stackoverflow.com/questions/15236238/current-state-
of...](http://stackoverflow.com/questions/15236238/current-state-of-haskell-
soft-real-time)

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...](http://www.haskell.org/ghc/docs/7.0.1/html/users_guide/runtime-
control.html)

------
MaxGabriel
Cool. Does Haskell have a great web development tutorial out there that could
use this?

~~~
PeterisP
The "book" for Yesod framework is quite like a walkthrough -
[http://www.yesodweb.com/book](http://www.yesodweb.com/book)

------
RyanZAG
I get the desire, but you'll never be able to popularize Haskell because the
only people who want to use it are math majors, and most web devs are not math
majors.

If you want to popularize Haskell you'll need to rework the syntax at the very
least.

~~~
codygman
> the only people who want to use it are math majors

 __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://yannesposito.com/Scratch/en/blog/Haskell-the-Hard-Way/)

[http://book.realworldhaskell.org/](http://book.realworldhaskell.org/)

[http://learnyouahaskell.com/](http://learnyouahaskell.com/)

[http://adit.io/posts/2013-04-17-functors,_applicatives,_and_...](http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html)
(with web dev applicable example)
[http://en.wikibooks.org/wiki/Write_Yourself_a_Scheme_in_48_H...](http://en.wikibooks.org/wiki/Write_Yourself_a_Scheme_in_48_Hours)

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.

~~~
PeterisP
The syntax for "record types" \- elements of named tuples - is really awkward
and pollute namespace.

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.

~~~
Fixnum
It's being fixed.

[http://www.reddit.com/r/haskell/comments/1rpte3/explanation_...](http://www.reddit.com/r/haskell/comments/1rpte3/explanation_of_the_new_haskell_records_extension/)

