About

This Website

Generator and Backend

I use a static content generator called Hakyll, it is written in Haskell. I mostly wanted to try this language, but some features where particularly appealing to me:

• Pandoc support:

  Pandoc is a document converter written in Haskell, it is very complete and can convert most markup languages to HTML and PDF. One cool thing is that Hakyll as built-in rules for document conversion, so you can write your content in Markdown, AsciiDoc, Org-Mode, etc…

• Haskell:

  This language possesses some very interesting features, but mostly, it is purely functional, prevent unspecified side effects, and its foundations are laid on a strict theory.

• Served by Caddy2:

  The minimal loss in performances (compared to Nginx) is counterbalanced by the ease of use. My complete config file (even with specific HTTP headers and TLS ciphers) is about 20 lines.

• Hosted on a VPS at OVH.

The future

I plan to move away from this Haskell generator, it has some advantages but I’m not happy with the ecosystem and its chain of dependecies. I envision to keep pandoc for the moment, as it is disponible on most distrubutions, but to replace hakyll by a lighter solution written in C (maybe this one: https://git.codemadness.org/saait/file/README.html).

Tags

I was able to add tags to Hakyll thanks to Javran’s tutorial.

Where are the Sources ?

I’m an advocate of FOSS, but I use separate branches to write posts, some of them may never be merged into the master, and I don’t want to make public the drafts.

From what I understand, there is no simple way to keep private a branch on a public repo:

• Neither on Gitlab

• Nor on Github

  I like to keep things simple, so until I find a better solution than these ones, I will keep this repo private.

  A last, you can click here to get my site.hs.

  {-# LANGUAGE OverloadedStrings #-}
  
  import Hakyll
  
  postCtx :: Context String
  postCtx = dateField "date" "%B %e, %Y" <> defaultContext
  
  postCtxWithTags :: Tags -> Context String
  postCtxWithTags tags = tagsField "tags" tags <> postCtx
  
  rssFeed :: Rules ()
  rssFeed = do
    let myFeedConfiguration =
          FeedConfiguration
          { feedTitle = "David Tabarie"
          , feedDescription =
              "A personal website/blog on tech and other things..."
          , feedAuthorName = "David Tabarie"
          , feedAuthorEmail = "david.tabarie@pm.me"
          , feedRoot = "http://dtabarie.com"
          }
  
    create ["rss.xml"] $ do
      route idRoute
      compile $ do
        let feedCtx = postCtx `mappend` bodyField "description"
        posts <- fmap (take 10) . recentFirst =<< loadAllSnapshots "posts/*" "content"
        renderRss myFeedConfiguration feedCtx posts
  
  matchKeys :: Rules ()
  matchKeys = do
    match "keys/*" $ do
      route idRoute
      compile copyFileCompiler
  
  matchRobotTxt :: Rules ()
  matchRobotTxt = do
    match "robots.txt" $ do
      route idRoute
      compile copyFileCompiler
  
  matchImages :: Rules ()
  matchImages = do
    match "images/*" $ do
      route idRoute
      compile copyFileCompiler
  
  matchFonts :: Rules ()
  matchFonts = do
    match "fonts/*" $ do
      route idRoute
      compile copyFileCompiler
  
  matchCV :: Rules ()
  matchCV = do
    match "cv/*" $ do
      route idRoute
      compile copyFileCompiler
  
  matchCSS :: Rules ()
  matchCSS = do
    match "css/*" $ do
      route idRoute
      compile compressCssCompiler
  
  matchAbout :: Rules ()
  matchAbout = do
    match "about.org" $ do
      route $ setExtension "html"
      compile $
        pandocCompiler >>=
        loadAndApplyTemplate "templates/default.html" defaultContext >>=
        relativizeUrls
  
  matchContact :: Rules ()
  matchContact = do
    match "contact.org" $ do
      route $ setExtension "html"
      compile $
        pandocCompiler >>=
        loadAndApplyTemplate "templates/default.html" defaultContext >>=
        relativizeUrls
  
  matchCVFormats :: Rules ()
  matchCVFormats = do
    match "cv-formats.org" $ do
      route $ setExtension "html"
      compile $
        pandocCompiler >>=
        loadAndApplyTemplate "templates/default.html" defaultContext >>=
        relativizeUrls
  
  matchPosts :: Tags -> Rules ()
  matchPosts tags = do
    match "posts/*" $ do
      route $ setExtension "html"
      compile $
        pandocCompiler >>=
        loadAndApplyTemplate "templates/post.html" (postCtxWithTags tags) >>=
        saveSnapshot "content" >>=
        loadAndApplyTemplate "templates/default.html" (postCtxWithTags tags) >>=
        relativizeUrls
  
  createArchive :: Rules ()
  createArchive = do
    create ["archive.html"] $ do
      route idRoute
      compile $ do
        posts <- recentFirst =<< loadAll "posts/*"
        let archiveCtx =
              listField "posts" postCtx (return posts) <>
              constField "title" "Archives" <> defaultContext
        makeItem "" >>= loadAndApplyTemplate "templates/archive.html" archiveCtx >>=
          loadAndApplyTemplate "templates/default.html" archiveCtx >>=
          relativizeUrls
  
  matchIndex :: Rules ()
  matchIndex = do
    match "index.html" $ do
      route idRoute
      compile $ do
        posts <- recentFirst =<< loadAll "posts/*"
        let indexCtx =
              listField "posts" postCtx (return posts) <>
              constField "title" "Home" <> defaultContext
        getResourceBody >>= applyAsTemplate indexCtx >>=
          loadAndApplyTemplate "templates/default.html" indexCtx >>=
          relativizeUrls
  
  matchTemplates :: Rules ()
  matchTemplates = do
    match "templates/*" $ compile templateBodyCompiler
  
  makeTagPage :: Tags -> Rules ()
  makeTagPage tags = do
    tagsRules tags $ \tag tagpattern -> do
      let title = "Posts tagged \"" ++ tag ++ "\""
      route idRoute
      compile $ do
        posts <- recentFirst =<< loadAll tagpattern
        let ctx =
              constField "title" title <>
              listField "posts" (postCtxWithTags tags) (return posts) <>
              defaultContext
        makeItem "" >>= loadAndApplyTemplate "templates/tag.html" ctx >>=
          loadAndApplyTemplate "templates/default.html" ctx >>=
          relativizeUrls
  
  main :: IO ()
  main =
    hakyll $ do
      matchKeys
      matchRobotTxt
      matchImages
      matchFonts
      matchCV
      matchCSS
      matchAbout
      matchContact
      matchCVFormats
      tags <- buildTags "posts/*" (fromCapture "tags/*.html")
      makeTagPage tags
      matchPosts tags
      createArchive
      matchIndex
      matchTemplates
      rssFeed

  Anyway, feel free to ask me for the public code.

Cookies

I don’t use any, nor do I collect any of your data.

Donate

• If you’re using Brave, you can tip me.

• Using Monero:

  Monero QR Code.

  

• Using Wownero:

  Wownero QR Code.

  

• Using Oxen:

  Oxen QR Code.

  

• I don’t use Bitcoin, here are some reasons why (TLDR: it was a good proof of concept, but it serve no real use-case):

  • Paper: “Bitcoin will bite the dust”
  • Luke Smith’s article
  • Matt Ranger’s article

• Rant incoming: As of 2022, I feel that most crypto projects are useless, some of them like the ones listed above win at least the argument of ensuring some anonymity and untracability (which may or may not be a good idea, but at least that’s better than a public ledger).

  I had some optimism toward crypto-currencies in the past, but seeing now that the market is mostly inundated with scams and useless projects, I don’t think we will get something actually usable in the real world unless a massive crash reboot everything and clean the table (my guess is that the so-called “stable-coins” will help).

  Just look at the top 10 coins with respect to market cap, and ask yourself for what would you use any of them in real life (a non speculative use):

  1. Bitcoin
  2. Ethereum
  3. Tether
  4. USD Coin
  5. Binance Coin
  6. Cardano
  7. XRP
  8. Binance USD
  9. Solana
  10. Dogecoin

  The allocations of resources reflect the lacks of maturity in the space, maybe we will see some interesting innovations some day, but it will likely not come from some VC firm with shady allocations.

  Another problem: for now, the mechanism of valuation of these assets reflect the one found in artistic works, which is quite problematic for currencies.

“Your CV theme looks like LaTeX ModernCV”

It’s the goal, but it’s pure HTML/CSS. That way it can be responsive, unlike a LaTeX to HTML conversion, and the source is written in Markdown.

It draws its inspiration from these two websites (a big thanks to them):

• https://mszep.github.io/pandoc_resume/

• https://resume.chmd.fr/

I adapted the CSS to be responsive, here is the current version.