Oh god, don't tell me about janky stack.

My stack for the blog is Org Mode compiled by Emacs into HTML, which then gets parsed by my Common Lisp static site generator. It's a weird setup, but it came to be because:

- The rest of the site, and the overall template, is generated straight from Common Lisp (using a much saner syntax for markup and styling than HTML/CSS),

- writing a parser for Org Mode for anything but the most basic features is a rather complicated endeavor, so it's better to let Emacs deal with it and then clean up the exported markup,

- I also imported posts from my old Wordpress blog, as HTML dumped from a database, so I had the tools to slice and dice DOM in my CL generator anyway.

I really hate how bad this design is. It needs rewriting from scratch into something designed closer to a build system, but that would take a lot of time, so I procrastinate on that endlessly. On the other hand, writing blog articles in Org Mode is super fun, so the frustrations cancel out with the benefits.

That's indeed a janky setup :P

What libraries / frameworks do you use in Common Lisp to generate the site?

CL-WHO - to generate HTML

LASS - to generate CSS

colorize - to colorize source code snippets and embed documentation links in them

Plump, Plump-SEXP, CLSS - for occasional fixing of imported HTML documents "on the fly"

Eh, not sure about that one. I don't particularly like Ruby or Liquid but I run my blog on Jekyll because it is the right set of tradeoffs for me (works on GitHub Pages, produces a static site), not because I'm particularly invested in the stack. It works, I write things in it, from time to time I extend it to support some new thing I am putting in the blog post I'm working on.

Nothing wrong with that.

Making my blog from "scratch" is a source of motivation for me to actually write articles. The experience so far has been overwhelmingly positive.

I'd love to see a blog post on how your rust/org-mode blog works.

I wrote an article about that here: https://dpbriggs.ca/blog/making-a-blog-with-rust-and-orgmode

The main changes since that article is I use systemd services to manage caddy / webserver instead of tmux sessions.

The short of it is: rocket + tera + org-mode html export + some amount of parsing. There didn't exist high quality org-mode parsing crates when I made the blog.

You can learn more about the org-mode parts from the source code: https://github.com/dpbriggs/dpbriggs-blog/blob/f4936fa2dafea...

Nice, using similar workflow for my blog, emacs export + some post-processing [0].

Even with high quality parsing libraries, when you dip into the most advanced features of org-mode (like literate programming via babel), you end up needing emacs anyway. And it's much more pleasant to tweak existing export code, than figuring out how to reimplement it from scratch.

[0] https://github.com/karlicoss/beepb00p/blob/master/src/compil...

I checked out your articles and I like your writing style!

I thought about doing batch export but ended up being too lazy to integrate it in my release flow. My compromise is to use this snippet:

    (defun make-blogging-mode ()
      (interactive)
      (toggle-word-wrap)
      (toggle-truncate-lines)
      (flycheck-mode)
      (flycheck-vale-toggle-enabled)
      (add-hook 'after-save-hook 'org-mode-export-hook)
      )

And this find-file hook in my blog template:

    # -*- find-file-hook: make-blogging-mode -*-

My new computer is beefy enough that I barely notice the export on save. I wouldn't recommend this on slower boxes as it freezes emacs for a bit.

Thanks! :) There is also 'org-export-in-background' which can export asynchronously! https://orgmode.org/manual/The-Export-Dispatcher.html

TIL. Thank you