<!DOCTYPE html>
<html lang="en">
    <head>
<!--LOAD include/stdhead.html -->
        <title>blog: kethel/2 - m1kadev.nl</title>
    </head>

    <body>
<!--LOAD include/stdnav.html -->
        <main>
            <h1>Kethel/2: A high level overview of a low-level SSG</h1>
            <p>
                I've been meaning to rewrite my old elixir-based SSG for a newer, and easier to set up alternative.
                So, what language is the most portable, has universal support across linux distributions?
                <code>ISO/IEC 9899:1999</code>, or <em>The C Programming Language</em> - of course!
            </p>
            <p>
                Kethel isn't a perfect SSG by any means; it sometimes just writes garbled data to the output HTML fil
                if a template or TSV ends with a newline, is probably vulnerable to several buffer overflow attacks,
                as no bounds checking is implemented at all for the templates, and treats HTML as plain text, with only a
                <code>strncmp</code> "parser". Yet, it still works! <br />
                So, I'd like to explain some design decisions behind Kethel/2, and convince YOU to use less CSS in your website!
            </p>
            <h2><code>aggregate</code>, and my "solution" to index page generation</h2>
            <p>
                Aggregate was the 2nd program I wrote for my site, which fills the spot of a 'compiler', if we're following
                the compiler/linker metaphor. The RSS feed generation for my site before was really iffy
                (<a href="https://www.rfc-editor.org/info/rfc822/">RFC822</a> and <a href="https://www.rfc-editor.org/info/rfc2822/">RFC2822</a> are to blame).
                I could definitely have switched to atom feeds instead of RSS in the original kethel, but i had better things to do with my time then
                refactor all my elixir code.
                <span>(this isnt an issue with elixir per se, but moreso that i didnt really wanna debug MY code every time i wanted to make a change
                    to my site, architecturally kethel1 kinda sucked)</span>
            </p>
            <p>
               The general idea with aggregate is that you provide a TSV file, with some free-form data, and aggregate could transform that into an index page,
               but also an atom <code>&lt;entry&gt;</code>, with proper tag uri support. Coming back to the first sentence about the 'compiler' metaphor,
               aggregate does not generate the final html, but only take the TSV and generate a <code>mkpage</code>-compatible 'object page'. Since I've
               only used C in this project, I already had an obj folder for intermediate output, so it was easy to just generate all the indexes, and
               various feed entries, and use <code>mkpage</code> as an <em>ersatz</em>-linker, to generate the final XML/HTML.
            </p>
            <h2>So, what is this <code>mkpage</code> all about then?</h2>
            <p>
                mkpage is the original program that orchestrated all HTML generation, inspired by PHP's "it's just html!" approach, and
                <a href="https://zed.dev/">my code editors</a> unwillingness to let me use unclosed tags in a template file. I chose to use simple HTML comments
                with some meaning, which I then decode in C.
            </p>
            <p>
                However, it quickly become clear that my linear-time no-seek approach to page generation wasnt really going to scale to, say,
                more than 2 pages in a directory. mkpage only supports 2 commands, <code>LOAD</code> and <code>STAMP</code>. <code>LOAD</code>
                takes a path, and puts the file's contents where the directive used to be.
                <code>STAMP</code> is used mostly for atom feed generation, but is generalised to work in most cases where you'd need a timestamp.
            </p>
            <p>
                Therefore, aggregate deals with most of the more complex parts of my websites build pipeline.
                Aggregate supports a lot more commands, compared to mkpage.
            </p>
            <ul>
                <li><code>ANCHOR</code> - generates a reproducible id for any content-item, another issue i was dealing with in kethel2 </li>
                <li><code>PUT</code> - pastes a tsv table value, verbatim, does still have some issues with newlines thought</li>
                <li><code>LINK</code> - generates a permalink to a (section of a) page, for my microblog this uses </li>
                <li><code>ATOM</code> - generates all atom metadata for an entry</li>
                <li><code>DATE</code> - pretty prints the date</li>
            </ul>
            <h2>So that's it, honestly</h2>
            <p>
                Besides some dependency modelling in make, this is all that Kethel2 comes with. I hope that you find some inspiration
                in my architectural choices here, and if not, i'll still keep enjoying my sub-halfsecond build times.
            </p>
            <figure>
                <blockquote><em>Merci d'avoir lu!</em></blockquote>
            </figure>
        </main>
	<hr>
<!--LOAD include/stdfooter.html -->
    </body>
</html>