Learn Haskell by building a blog generator – a project-oriented Haskell book

Learn Haskell by building a blog generator – a project-oriented Haskell book(lhbg-book.link)

230 points by gilmi 3 years ago | 40 comments

That's the perfect learning project because there's something tangible at the end.

Whenever the question of "How do I learn Haskell" comes up, I always suggest to come up with a project that would be useful on its own, regardless of the technology used to create it, and use Haskell to do it. In my case it was a pandoc filter to embed plots in documents (https://github.com/LaurentRDC/pandoc-plot), which was ultimately useful to create my PhD dissertation.

There's only so much you can learn about Haskell by working through toy examples.

cholantesh 3 years ago | |

Great project; I'd have loved to have had it when I was writing my dissertation - hell, I'd have liked anything that would have let me write it in vim and just generate the final submission per the university's format, because I hate Word.

_query 3 years ago |

If you want to do web development with Haskell beyond building a blog generator, a good starting point is IHP (https://ihp.digitallyinduced.com/ https://github.com/digitallyinduced/ihp). IHP is Haskell's version of Laravel/Rails/Django. It's really a superpower to have Haskell's type system combined with the rapid development approach of Rails :) (Disclaimer: I'm founder of the company that makes IHP)

embwbam 3 years ago | |

I think IHP for learning Haskell has the same flaw that Rails always did. You have no idea what is part of the language and what is part of the framework. You'll get stuck once you stray from the golden path.

I'd recommend starting with Scotty instead. It's much easier to understand what it is doing. Use Lucid for HTML rendering, and your choice of DB libraries (I like Selda). These all avoid template haskell and don't rename any prelude functions. If you add them one at a time you'll see what each one is offering and understand where to go when you need to do something more complicated

froza 3 years ago | |

I was tempted to try it, but then I saw that some core features (like mysql) are for paid versions only so its a big red flag already

_query 3 years ago | | |

Mysql support is not implemented at the moment. If there's someone paying for the development we could have it. You're of course also free to contribute it yourself to the open source version, then it wouldn't need to be part of the commercial version.

Some more background on why IHP has a paid variant can be found here: https://ihp.digitallyinduced.com/blog/6392ad84-e96a-46ce-9ab...

cultofmetatron 3 years ago | | |

software needs work and devs have bills. its unfortunate but we don't have a government currently giving grants to open source devs yet.

bitmapper 3 years ago | |

I'm really not a fan of IHP for that purpose due to how it redefines so much of the Haskell Prelude without making it clear it does that.

My71staccount 3 years ago | |

Ah, I was wondering why you post about IHP on most Haskell threads here and I just noticed it is a commercial product. You should probably disclose that this is an advertisement if it is permitted at all.

_query 3 years ago | | |

IHP is mostly an open source project.

I comment on most Haskell threads about IHP because I would love to see more Haskell adoption. Most people think Haskell is about Monads and Math, with IHP we want to show that Haskell can be used in a very productive way to build things. The comments are typically well received, so I don't see any problem with this.

matijash 3 years ago |

This is really cool! I've been looking for something like for a while - my learning path was through LYAH and Real-World Haskell (also tried Haskell from the first principles but a bit too extensive IMO). I think this would fit in perfectly between LYAH and RWH.

I am using Haskell mostly for writing compilers (https://github.com/wasp-lang/wasp currently), but I believe if the tutorial isn't using a lot of specialized libraries/frameworks (which seems to be the case from the first glance), a majority of the material taught should be transferable to any domain.

gilmi 3 years ago | |

Thanks!

bwanab 3 years ago |

If you’re more inclined to visual and/or musical arts, I’d recommend “Th Haskell School Of Expression” by Paul Hudak. He guides you through the language and the techniques with an eye for concise, expressive code that has good runtime characteristics.

mbrodersen 3 years ago |

Kudos to the author. The best way to teach something is to start with a foundation of nothing and then step by step building layers of understanding on top of it. Most other Haskell tutorials fail to do this.

gilmi 3 years ago | |

Thank you!

Iceland_jack 3 years ago |

Oh this looks fun getStructureString and render can be defined as record selectors

  newtype Structure = Structure { getStructureString :: String }
  newtype Html      = Html      { render             :: String }

BlockArguments let you write expressions like myhtml

  myhtml :: Html
  myhtml =
    html_
      "My title"
      ( append_
        (h1_ "Heading")
        ( append_
          (p_ "Paragraph #1")
          (p_ "Paragraph #2")
        )
      )

in a more domain-specific style. De gustibus, but some may prefer it to the parentheses.

  {-# Language BlockArguments #-}

  myhtml :: Html
  myhtml =
    html_ "My title" do
      append_
        do h1_ "Heading"
        do append_
             do p_ "Paragraph #1"
             do p_ "Paragraph #2"

or using the associativity of append_ = (<>)

  myhtml =
    html_ "My title" do
      h1_ "Heading" <> p_ "Paragraph #1" <> p_ "Paragraph #2"

  myhtml =
    html_ "My title" do mconcat
      [ h1_ "Heading"
      , p_ "Paragraph #1"
      , p_ "Paragraph #2"
      ]

All examples of 'concat . map' can be replaced with.. concatMap :Ð

zeckalpha 3 years ago |

I have found Hakyll to be useful in this space, if you want to move from building your own to configuring/extending your own.

hans1729 3 years ago |

At first sight I’ve read “an object-oriented Haskell book”.

[brief pause for contemplating the thought]

Naturally, someone went there: https://www.parsonsmatt.org/tutorials/

greymalik 3 years ago | |

The linked articles are actually about how to translate problems from an OOP perspective into idiomatic Haskell.

danuker 3 years ago |

How you would write tests in a real project?

I suppose it's not writing out the entire program and then writing the tests, as seems to be implied. That would mean a lot of manual testing.

Or is there a Haskell REPL where you can try out small pieces before saving them?

gilmi 3 years ago | |

When you create a project description for your project (for the package manager) you can define a library, executables and test suites.

In the test suite you write your tests against the library. You can do that at any stage, even before writing a line of library code.

But yes, Haskell also has a REPL that can be used to experiment with code.

lgas 3 years ago | |

In addition to the other good answers you've gotten, I would like to point out that Haskell has QuickCheck (https://hackage.haskell.org/package/QuickCheck) which, if I'm not mistaken, more or less pioneered property testing. Property testing libraries are available in many languages now but they never seem to be as capture the magic of QuickCheck. (There's also https://hackage.haskell.org/package/hedgehog which is sort of a "modern alternative" to QuickCheck but I still prefer the OG).

rowanG077 3 years ago | |

You have testing libraries in Haskell just like in every other languages. For example: https://hackage.haskell.org/package/tasty

jose_zap 3 years ago | |

Yes, there is GHCi, the Haskell interpreter and repl comes bundled with the compiler.

You can load your entire project in the repl and try your functions there.

jokethrowaway 3 years ago | |

HUnit is a popular choice: https://mmhaskell.com/testing/test-driven-development

ypeterholmes 3 years ago |

For anyone that does decide to learn Haskell, you can easily get a job afterwards working on the Cardano blockchain. Smart contract devs are in high demand, and Cardano uses a variant of Haskell that is relatively unique to the space.

heldrida 3 years ago | |

I've been following for at least a year and find that the jobs pay is very low in comparison to Rust; or Solidity.

I also don't see much jobs available.

Where do you see those job listings?

alephnan 3 years ago |

Is the website/book/blog self-hosting?

https://en.wikipedia.org/wiki/Self-hosting_(compilers)

gilmi 3 years ago | |

No. It is built with mdbook[0].

[0]: https://rust-lang.github.io/mdBook

{-# Language BlockArguments #-} myhtml :: Html myhtml = html_ "My title" do append_ do h1_ "Heading" do append_ do p_ "Paragraph #1" do p_ "Paragraph #2"

myhtml = html_ "My title" do h1_ "Heading" <> p_ "Paragraph #1" <> p_ "Paragraph #2" myhtml = html_ "My title" do mconcat [ h1_ "Heading" , p_ "Paragraph #1" , p_ "Paragraph #2" ]

{-# Language DerivingStrategies #-} {-# Language GeneralizedNewtypeDeriving #-} newtype Structure = Structure String deriving newtype (Semigroup, Monoid) append_ :: Structure -> Structure -> Structure append_ = (<>) empty_ :: Structure empty_ = mempty

{-# Language StandaloneKindSignatures #-} import Data.Kind (Type) type Tuple :: Type -> Type -> Type data Tuple a b = Tuple a b type Either :: Type -> Type -> Type data Either a b = Left a | Right b