Jasper Van der Jeugt

Love SSGs too! Came here to share praise for Hakyll[1], for people with an FP leaning. Predictably, it's not easy to get started, but once you're into it the power of building your own arbitrary content "compilers" (and template extensions etc etc) is pretty impressive. [1] https://jaspervdj.be/hakyll/

I didn't see Hakyll [1] on the list. It is a minimal static site generator written in Haskell. I have just set it up for my first personal site [2]. It is my first experience using a static site generator, and so far I can highly recommend giving it a go. [1] http://jaspervdj.be/hakyll/ [2] http://willsewell.name

Fell in love with Pandoc after seeing my friend's online course notes[0] processed using it. For websites, it's even more brilliant in conjunction with Hakyll, a static site generator that allows you to create site generation logic via an EDSL. http://jaspervdj.be/hakyll/

As far as mechanics go, I've found a great compromise between the power and convenience of a CMS and the simplicity of a static page: using a static site generator. I personally prefer Hakyll[1], as you might have guessed :P. This makes managing a structured site easy without having to configure a complicated server. Of course, it also means you can't have much dynamic content. For something simple--say comments--you could use an external service like Disqus, but you won't be able to do much beyond that without running your own server. [1]: http://jaspervdj.be/hakyll/

Do you try Hakyll ? http://jaspervdj.be/hakyll/ The best website static generator I think :-) And you can host on EU law with Clever Cloud

Also, I can't resist but to mention hakyll[1]. I switched from nanoc to hakyll[2]. The two of them are great to use. [1] - http://jaspervdj.be/hakyll/ [2] - http://yannesposito.com/Scratch/en/blog/Hakyll-setup/

For those interested in a lighter weight personal or small scale static site with Haskell, I recommend Hakyll: http://jaspervdj.be/hakyll/

Also recommend Hakyll! http://jaspervdj.be/hakyll/ The "configuration" is a Haskell program that uses the Hakyll library as a DSL. I use it for my home page: http://chrisdone.com/ Sauce: https://github.com/chrisdone/chrisdone-homepage/blob/master/hakyll.hs

Thanks. I do not have a public, detailed description of how my blog works. But in short, my site build system is powered by a Makefile that invokes Hakyll [1]. My Hakyll configuration has the following rule baked into it for generating HTML docs from Markdown docs in the `posts/` directory: match "posts/*" $ do route $ setExtension "html" let ctx = postCtx tags compile $ pandocMathCompiler >>= loadAndApplyTemplate "templates/post.html" ctx >>= saveSnapshot "content" >>= loadAndApplyTemplate "templates/add-comments.html" ctx >>= loadAndApplyTemplate "templates/default.html" ctx >>= relativizeUrls The `pandocMathCompiler` bit invokes Hakyll's Pandoc subsystem with support for rendering formulas using MathJax. The site Makefile also has rules to build PDF versions of the articles that I want to typeset. The rules just invoke Pandoc directly. For example, here's the rule used to generate the PDF file in my prior comment: sampling-with-sql.pdf: posts/2024-08-23-sampling-with-sql.md ( cd posts && pandoc --metadata-file=../templates/latex-header-includes.yaml -t pdf -o ../[email protected] --pdf-engine=pdflatex ../$< && mv -f ../[email protected] ../$@ ) It's basically a straightforward invocation of Pandoc with a little shell boilerplate to prevent the PDF file from being moved into its final location unless Pandoc exits with success. The Makefile has a final "push" target that makes sure the…

Build a snake game in stages: https://github.com/lsmor/snake-fury Build a small web-app: https://jaspervdj.be/posts/2017-12-07-getting-things-done-in-haskell.h… (the video link is down, but exists somewhere on youtube.)

Others have mentioned static site generators. I like Hakyll [1] because it can tightly integrate with Pandoc [2] and allows you to develop custom solutions (such as `.pdf` downloads) if your needs ever grow. [1]: https://jaspervdj.be/hakyll/ [2]: https://pandoc.org/

> No standard and easy way of implementing interfaces. > In Haskell, this is done with typeclasses ... > In OCaml there’s no way to do this. I have to explicitly pass functions along with my values, maybe in a product type, or with a functor, or as an argument. Haskell is a mixed community / paradigm language too. I routinely program in "Braindead Haskell" (keep stuff simple and direct as much as possible). Funnily, in that programming style, using typeclasses for _all_ interface types is bad style. Instead, the Handle pattern [0] can be used. Which really is just shoveling functions in a product type. And imagine - it works worderfully. Everyone has to find their own style I guess. [0]: https://jaspervdj.be/posts/2018-03-08-handle-pattern.html

It's interesting to see a lot of FP communities independently arriving at the same architectural structures. See e.g. Haskell's "handle:" https://jaspervdj.be/posts/2018-03-08-handle-pattern.html

plenty of projects that use either of the following on a regular basis: - https://www.aosabook.org/en/posa/warp.html - https://morpheusgraphql.com/ - https://higherkindness.io/mu-haskell/ - https://github.com/hasura/graphql-engine - https://postgrest.org/en/stable/ - https://www.shellcheck.net/ - https://dhall-lang.org/ - https://haskell-miso.org/ - https://github.com/jgm/gitit - https://jaspervdj.be/hakyll/ - https://github.com/IHaskell/IHaskell - https://tweag.github.io/HaskellR/ (https://idontgetoutmuch.wordpress.com/2018/05/19/cartography-in-haskel… The list can go on, it really depends on what level of "real-worldness" you consider to be real.

Btw there is a static page generator utilizing pandoc directly: hakyll[1]. Since it's configuration is done via haskell source code file, you need to be willing to learn a bit of haskell though. [1] https://jaspervdj.be/hakyll/

In case anyone is curious about the tech: I'm using Hakyll (https://jaspervdj.be/hakyll/index.html) to generate the static website and https://github.com/jaspervdj/hakyll-citeproc-example for reference handling (but adapted so that I have a ".bib" file per blog post). The reference handling was really painful when I tried to do it manually at first, but hakyll-citeproc has made it really easy. A lot of websites let you download a "citation" (in bibtex format) so you can just copy & paste it in your ".bib" file. For others, I use https://www.bibme.org/bibtex to generate one. For deploy, I use a simple deploy script (4 lines of code) that pushes it up to an amazon s3 bucket and clears the Cloudfront cache.

use Hakyll if you want pandoc generated HTML for the website https://jaspervdj.be/hakyll/

A right click, view source mentions hakyll https://jaspervdj.be/hakyll/ Probably in combination with org-mode http://wikemacs.org/wiki/Blogging

You can avoid parens and have some fun building up HTML with combinators. > numbers n = docTypeHtml $ do > H.head $ do > H.title "Natural numbers" > body $ do > p "A list of natural numbers:" > ul $ forM_ [1 .. n] (li . toHtml) https://jaspervdj.be/blaze/tutorial.html

I'm using Pandoc through Hakyll[1]. Hakyll does the static site stuff, and delegates to Pandoc for document conversion. Configuration is in Haskell. [1]: https://jaspervdj.be/hakyll/

Here is a tutorial on creating a static site with Hakyll and Github: https://begriffs.com/posts/2014-08-12-create-static-site-with-hakyll-g… EDIT: Tutorials about Hakyll: https://jaspervdj.be/hakyll/tutorials.html

Not necessarily even html, you could write your HTML in a DSL of some sort, write functions that generate HTML, etc. Using that you could keep the backend homogeneous. For example, something like https://jaspervdj.be/blaze/tutorial.html

If you want something a little more involved, https://jaspervdj.be/hakyll/ is a static site generator that uses pandoc under the hood. Uses a Haskell DSL

The author's site appears to be built using Hakyll https://jaspervdj.be/hakyll/, which is a Haskell static site generator. You can find the source for this particular site on Github: https://github.com/barrucadu/barrucadu.co.uk The "clean look" you refer to is mostly thanks to custom CSS though - nothing specifically related to Hakyll. If you're thinking about building a similarly-styled blog or personal site, you could start by studying the styles this author used on their site: https://github.com/barrucadu/barrucadu.co.uk/tree/master/css

There's also Blaze which is a nice haskell library to write templates or just plain HTML using combinators: https://jaspervdj.be/blaze/tutorial.html

This is roughly how I learned; I used Hakyll[0] to make my personal site, and working with the Compiler monad it uses taught me to understand monads and use do notation. It's way easier to learn when you have a reason to be learning, and abstractions always make more sense when you have a case to motivate them. [0]: http://jaspervdj.be/hakyll/

Hakyll, which is a static site generator written in Haskell http://jaspervdj.be/hakyll/

I found the tool used to generate the blog interesting. Hakyll, a static site generator for Haskell inspired by Jekyll, which uses pandoc to generate HTML from Markdown. http://jaspervdj.be/hakyll/

> and yet nobody can ever show me anything written in it other than yet another compiler. http://johnmacfarlane.net/pandoc/ http://git-annex.branchable.com/ http://jaspervdj.be/hakyll/ You are welcome :)

Hakyll (http://jaspervdj.be/hakyll/) ist pretty sweet if you know Haskell.