for example, say you want to print the visiting users IP address - how would you do this on a statically generated website?

Personally? CGI. These are mostly exceptions. Most or your web site is still static. For dynamic elements, I would probably just use pp and create a static binary that would handle dynamic content.

another example - i generate all of my RSS feeds on my homepage when my website starts up. this ensures that i get a fresh copy of my friends’ latest posts.

Simple cron to update your index.html, again exception from presenting mostly static files.

i decided that i would host a website on a machine that i controlled, and program in plain old HTML, and edit everything by hand using vim.

~ * ~ and so i gave birth to the worst workflow ever used ~ * ~

the first draft of https://j3s.sh was built like this - it is where a lot of my ideas for the layout came from. the website still looks largely the same - writing HTML by hand felt a lot like doing intensive labor by hand - like dishwashing with a hand pump instead of a sink. it forced me into an insane level of minimalism in order to avoid the pain of having to use the workflow. i embedded styling directly into the HTML, made cross-site functions as minimal as possible, and shied away from much styling.

in a lot of ways, this experience was exactly what i had hoped for. it was simple, reliable, and maintainable - the HTML i wrote could be reused without modification, and i felt pretty confident that my site would be around for awhile. i had no dependencies. but i grew very tired of the workflow.

i wanted to handle “templating” of common functionality more efficiently. i didn’t want to use a pre-existing framework. i wanted to have fun. and i wanted to leave myself a lot of room for adjustment in case i changed my mind about this-or-that.

Sounds like my way to building mkws. Started with plain HTML but the problem was duplication. Wasn’t happy with any templating system so I settled on sh via pp. It’s great at manipulating plain text and presenting it in as much of a human friendly way as possible, so just render that plain text inside HTML.

mkws does the minimum required to build a static web site (generate HTML pages and make sure there’s little duplicated code), has a very powerful templating system, minimal set of dependencies (2, 3 if you add Markdown support and only because I preferred keeping stuff separated and not cramming every features in a single binary when there are already good existing web servers or Markdown processors or file change monitors like entr and everybody has their preferences) but you could just download the binary package and start building your web site skipping other downloads. Other dependencies are just a package manager install away but you can accomplish a lot with the standard UNIX tools. Also, it’s very customizable and very fun to use.

none of the above felt correct to me. more importantly, none of the above excited me.

For me personally, nothing feels “more correct” than serving plain HTML files.

I personally believe it’s a bad idea to have HTTP serving code in my web site, also routing. For, me, a web site is just a set of HTML files.

This was a fun post.

Spreading the Fossil love. One binary and one file for all your needs: website, source control, wiki, tickets, forum, chat. Deploying changes is just a commit, if you are using the auto-sync mode.

The downside is that its UI may be too spartan for some people’s tastes and they may need some time getting used to the system’s quirks. The documentation could be better with regards to web customisation too as it focuses on the source control bits way too much IMO.

    #!/bin/sh -eu
    #
    # deploy my website

    cd /home/j3s/code/j3s.sh
    if git fetch origin; then
      go build
      mv j3s.sh /usr/local/bin/j3s.sh
      service j3s.sh restart
    fi

It’s kind of disingenuous to say your website is one binary, when you’re running a script with 6 obvious dependencies every minute, to work around the fact that it’s not fully functioning by itself (eg, it needs to be rebuilt and redeployed).

My first website was artisanally handcrafted this way on vim as a set of files on our departments server in my user directory. I do not miss it except through the distorted lens of nostalgia.

I too like to understand everything about what I use. I gave up when I saw a photo of an Intel chip layout. I now resign myself to being an illiterate wielder of powerful magic.

My website is about 30 lines of shell; I guess I need to brag now: http://len.falken.directory/misc/writing-for-the-internet-across-a-human-lifetime.txt

Since this is go you can also trivially embed your templates etc in the binary :)

I’m still totally bought into the static site generation idea, but mine is handwritten by me personally.

My opinion is that static site generators are so easy to write that it’s no more work to make one from scratch than to learn an off the shelf one - if you’re already a programmer.

i love this article, it’s genuinely unclear to me if it

is ironic.

This should honestly probably be more common than it is, now that I think of it.

i spend a lot of time choosing my things, and i refuse to depend on anyone else

I hope I never have to work with this person.

maybe it’s just the operator in me thinking, but i’ve thought for a while you can do pretty powerful, even enterprise grade webapps, with just a true single go binary (compile the templates into the binary) and an sqlite database alongside… you could even use some caddy libraries to do the SSL and perhaps auto let’s encrypt for SSL, just open ports 80 and 443 for your redirects, challenges, and stuff like that, an auth provider if needed… and that’s the operational overhead…

database backups can happen via the web (either via ui or api calls), and if your use case requires more, litestream is there to stream in real time…

if object storage is needed, S3 apis are pretty commoditized now too, i wonder what percentage of web apps in use globally could be switched to this model… i imagine most

i wish i had the skills to create that, as i have some ideas for some fairly straightforward CRUD apps w/ < 1000 users that it seems to me i should have no problem running on a basic VPS, more users should be more than possible as long as the code is efficient

i’d like to devote some more time to that ideal but i feel like that’s a great stack… it seems like the toolkit is all there to do it…

maybe we can coin the new stack name… instead of the LAMP stack for linux, apache, mysql and php, we can call it the xSG stack…. xGS rolls off the tongue better,

x (any OS due to Go’s cross compilation abilities)
G, golang
S, sqlite

S standing for sqlite’s a bit of a stretch (microsoft sql server?)

maybe “xGSqlite” isn’t too long, but that’s like 5 syllables vs. LAMP’s 1….

maybe 2 binaries… one frontend routing traffic, and 1 with your webapp, this way your frontend binary could care for upgrades and could do seamless “blue/green” type deployments with your continuously integrated/delivered webapp, but part of me says a little downtime for upgrades and db migrations is not the end of the world, not for your vast majority

if git fetch origin; then...

Are you sure this works? Git fetch just puts the new commits from the origin into the .git folder, it doesn’t update the working copy of the files. To me it seems like you would be building the previous version every time.

Also if you like single binaries, check out MirageOS. You can compile your server along with its entire operating system into a single binary (with almost all Unix legacy cruft ruthlessly cut out), then run it on bare KVM.

Hey, I really enjoyed reading your article and discovering your website, along with your other projects. We have very similar taste it seems. I’m going to email you! :D

how do you handle TLS?

edit: ah, thanks to @jjasghar finding the source, I can infer that TLS is handled by a proxy(?), so it’s not really “my website is one binary”, but close enough I guess.

here’s the actual code: https://git.j3s.sh/j3s.sh/tree

It’s clever, not gonna lie.

I’ve done a single binary website a few times before too, heck my dpldocs.info website is one main binary plus one html archive per subdomain, but I don’t often actually go all the way to one binary anymore because the deployment of small changes gets more complicated - it means actually rebuilding the server. (btw the article’s “compilation speed is fast (less than 10s most of the time)” makes me laugh, since I consider a 3s full rebuild on my computer (a budget machine i got in 2015) to be my upper limit of tolerance… a 10s build would be painfully slow to me)

I don’t want to wait for the 2 1/2 second server rebuild and restart to see my change, so what I typically do is have the server binary load html templates from a runtime directory on demand. I actually have an open source example (though I haven’t pushed to it for a while, I so rarely git commit things lol, still good enough for this illustration): https://github.com/adamdruppe/ffr-bingo

The server serves its dynamic functions as well as files out of the assets folder (which are just plain css/js/images) and the templates folder, which are HTML fragments the server pieces together. It opens the template requested and the skeleton.html file and merges them; the server does skeleton.querySelector("main").replaceWith(template.querySelector("main") (basically). So then the shared stuff is shared and the rest just injected at runtime so I can edit those easily and hit refresh to instantly see the changes - no recompile lag (which is about 2.5s again but that’s 2.45s longer than I want to wait).

I’m still not completely happy with it, but I do find it overall works pretty well. (and btw, yes, I wrote all the code myself, from the webserver code to the script interpreter to the server-side dom and template implementation, that code is all in here https://github.com/adamdruppe/arsd/ if you’re interested, cgi.d is the web server, dom is the dom (lol), webtemplate.d does the piecing together of the template directory, etc)

edit: I should mention actually I prefer doing the traditional cgi instead of the web server for a lot of things too since then the server doesn’t even need to be restarted! but meh, that bingo site needs long-lived connections, so traditional cgi model didn’t fit that as well.

Nice work :)

My website is written in assembly o/