The intro part makes one glaring omission, which is surprisingly common when it comes to people claiming how difficult hosting stuff has become: A webhosting package at any of a large number of hosting providers. Nowadays with any non-crap choice it’s not FTP anymore but SFTP/SCP, and HTTPS isn’t an expensive add-on anymore, but other than that it’s the same as it has been for decades by now.

I totally get tinkering with self-hosting or cloud services, but you’re choosing more effort than necessary if all you want is some HTML hosted.

Well, one thing to make it easier is to just ignore the CDN part. It depends on the popularity and audience of the site of course, but in my experience you don’t need it for the majority of cases. Also the part on security is over emphasized, I think. It’s a static site, there is not much to hack.

I say this, apparently, as a graybeard, since my default choice is a VPS with Linux and Nginx, but I tried to help other, less technical people get their site on the web and what bothered me the most was that all the well-known hosting providers use a git based solution. This in itself complicates things immensely. For starters, normal people will not understand and use version control. Markdown without a GUI editor is difficult too. But: requiring one of those also assumes a generator and a deployment pipeline and this kills the quick feedback loop of changing something and immediately see what the effects are. It is really hard to see people struggle with this when you have your graybeard memories of just transferring a bunch of HTML to a server and see results instantly.

Since you’re the author, could you add main.document :is(li, p) { max-width: 67ch; } (or similar); the paragraph width problematic for comfortable reading–books are as wide as they are because that’s what is comfortable. “URL’s” should be “URLs”.

Content wise: I don’t agree with always needing to concatenate JS/CSS anymore with HTTP/2 and onward and this can lead to worse performance. As such, I often in simple static scenarios find it easier include each file independently as I would break them out for organization. This can help with build caching too as I don’t need to derive a concatenated file every time I edit one thing. Not mentioned is that many servers, especially self-hosted, can serve pre-compressed assets so you could make a Zopfli and Brotli compression part of your final build step before serving so the server doesn’t have to compress or cache it (specifically useful when the hardware isn’t the most powerful).

You could write a simple custom http server like https://mkws.sh/src/https.go. I add additional processing in the s cgi script, stuff like Content-Security-Policy (just to look good on online web site “health checkers”), serving pre compressed files, Cache-Control, directory handling (e.g. serve dir/index.html when asking for dir/)

All these stuff is outside the scope of the static site generator and it’s more tied to static site serving.

Also, I have written a small https tunnel:

    package main                                                    
                                                                    
    import (                                                        
            "crypto/tls"                                            
            "flag"                                                  
            "log"                                                   
            "net/http"                                              
            "net/http/httputil"                                     
            "net/url"                                               
            "os"                                                    
    )                                                               
                                                                    
    func main() {                                                   
                                                                    
            f := flag.String("f", "", "listen host")                
            t := flag.String("t", "", "connect host")               
            crt := flag.String("c", "", "path to cert file")        
            key := flag.String("k", "", "path to key file")         
                                                                    
            flag.Parse()                                            
                                                                    
            if *f == "" {                                           
                    flag.Usage()                                    
                    os.Exit(1)                                      
            }                                                       
            if *t == "" {                                           
                    flag.Usage()                                    
                    os.Exit(1)                                      
            }                                                       
            if *crt == "" {                                         
                    flag.Usage()                                    
                    os.Exit(1)                                      
            }                                                       
            if *key == "" {                                         
                    flag.Usage()                                    
                    os.Exit(1)                                      
            }                                                       
                                                                    
            proxy := httputil.NewSingleHostReverseProxy(&url.URL{   
                    Scheme: "http",                                 
                    Host:   *t,                                     
            })                                                      
                                                                    
            cert, err := tls.LoadX509KeyPair(*crt, *key)            
            if err != nil {                                         
                    log.Println(err)                                
                    os.Exit(1)                                      
            }                                                       
                                                                    
            config := &tls.Config{Certificates: []tls.Certificate{cert}, NextProtos: []string{"h2", "http/1.1"}}
            listener, err := tls.Listen("tcp", *f, config)          
            if err != nil {                                         
                    log.Println(err)                                
                    os.Exit(1)                                      
            }                                                       
            defer listener.Close()                                  
                                                                    
            err = http.Serve(listener, proxy)                       
            if err != nil {                                         
                    log.Println(err)                                
                    os.Exit(1)                                      
            }                                                       
    }

You could deploy the binaries also and just restart the tunnel and http server on deployment.

Anyway, in technical terms a static site is just a bunch of files on the file-system that are served with a simple HTTP server which when loaded via a browser present the user with something one can read (or listen to if accessibility is taken into consideration).

How is this different from what the ‘out-of-date’ wikipedia article says?