Hayden Shuker

I am a sophomore mechanical engineering student at Temple University. All code here is artisanal and handcrafted. I have no analytics, trackers, cookies, javascript, SEO or ads.

Organizational chops

Programming is probably the most flexible craft made by humanity. You can solve a problem in an whatever way using whatever set of abstracting tools. Any given process is easy to solve at least to a minimally functional level. That part is some tool knowledge and maybe some math chops. Any given (non-trivial) program is made of sub-processes and sub-processes and companion processes triggered between different conditions timed between each other and pointing to everything else. The hard part is the organization, comprehending all these pieces, sticking them together, keeping them inline and boiling off the redundancy until the whole thing can be a relatively cohesive unit. It feels like being the big mob boss and the little processes are your idiot goons.

If the problem becomes that big and zoomed out, the code just looks like colorful shapes. The idea as a whole is in plain english. Solving a problem for the first time means charts and documentation that get revised and replenished as the code does.

I got good at this method from engineering class. We loved complaining about this level of formality.

A lot more papers full come out of me now. Most of them these sloppy to-do lists and notes, anything to keep the structure from falling into a wash of letters and parenthesis.

Losing perspective

Programming has a lot of craftwork and nuance, but its also the thing where principle of operation can be most separated from experience. You can’t tell how your programs work by looking at them; You don’t need to care about what a program does to work on it. They call it ‘front end’ and ‘back end’. The divorce makes two problems: programs that feel good but run like hot garbage, and programs that run good but feel like hot garbage (most web apps and most Linux apps respectively). The former is just regular consumerist wasteful abundance squandering. The later is ‘technologist brain’: the obsession with tools and mechanisms, their tight inner workings with their purity and power to the extent that when we take off our navy blue jumpsuits and zoom out— we never considered what the machine does.

The unhelpful technologist mindset is process and paraphernalia, not for some intrinsic joy, but for a quest of abstract detached quality. These are the guys who made and bought cryptocurrency, and a similar affliction takes our Linux bro friends.

The blue collar is only as good as the white collar is only as good as the system is only as good as the blue collar. Their severance is doable and hideable, but not good.

I don’t want to be a programmer because that title seems deeply incomplete and what they do seems deeply superfluous.

Computing as meditation

Not just programming, but using a computer (at least a good one like mine) can be damn peaceful. I focus on pressing the keyboard with as little force as possible, I use inputs that keep my hands still and relaxed. The screen falls out of favor. Every mechanism literally happens at subvisible scale. Perception of the machine is limited to tools of the machine. The scenes become cloudy and the imagination becomes sharp, using the computer means developing a working model for what its doing. Bug fixing is bringing that model back to reality, drafting theories and sending out probes to see this untouchable object.

Summery/Objective/Background

Over the past three seasons, I built this website from the most minimal form. My process was very manual. This website is made of only static web pages. It is a pile of documents stored on GitHub servers and downloaded in their entirety (compare that to the built up ‘web-apps’ where every bit of content is shuffled in and out by the server). This has been very easy to make and scale. Early versions were one giant wizard scroll I would append new articles to. Since then I’ve added all the beloved front-end nuance.

My method didn’t changed though. I literally wrote each document by hand using a text editor even as I expanded to a few dozen pages. Old pages fell out of standard, and syndication got tedious (and skipped) as my archive and RSS feed took manual updating per every post.

My objective was to create a static site generator that can preserve and populate my content (prose and hypertext writing) with clean uniform code for other features (navigation bars, metadata etc.). Additionally I would automate the process of updating feeds.

Method

import os, glob

selectPath = input("path? leave blank for root.")

outputPath = 'desat/' + selectPath
path = 'handmade/' + selectPath

#for each file in directory 'path'
for filename in glob.glob(os.path.join(path, '*.html')):
    with open(os.path.join(os.getcwd(), filename), 'r') as f: # open in readonly mode

        #print the current file
        os.system('clear')

        print(f.read())
        f.seek(0)

        #create a word to carve out with. Only works if there is only one set of
        #splitable tags
        splitword = input("splitword?, or 's' for skip")
        if splitword == "s":
            continue

        #extract everything between the split word tags
        fraction = f.read().split("<" + splitword + ">\n")
        fraction = fraction + fraction[1].split("</" + splitword + ">\n")
        fraction.pop(1)
        output=fraction[1]
        
        os.system('clear')
        print(output)

        #optionally incase the new content as an article
        if input("incase in article tages?") == "y":
            output="<article>\n" + output + "</article>\n"
            
            os.system('clear')
            print(output)

        #save to file (optional)
        if input("save?") == "y":
            outfile = open(outputPath + vf.name.split("/")[-1], "w")
            outfile.write(output)

import os, glob, re

selectPath = input("path? leave blank for root.")
outputPath = 'sat/' + selectPath
path = 'desat/' + selectPath
headerFile = input("headerfile? Blank for defult. ")
if headerFile == '':
    headerFile = "header"

#import template files
header = open('templates/' + headerFile +'.html').read()
footer = open('templates/footer.html').read()

#for each file in directory 'path'
for filename in glob.glob(os.path.join(path, '*.html')):
    with open(os.path.join(os.getcwd(), filename), 'r') as f: # open in readonly mode

        #extract article title
        #this curently has the problem of the depreciated 'headline' tag. Running 
        #this program will clear that. Then I will rebuild the program.
        splitFile = re.split('<h2.*?>', f.read(), 1)
        f.seek(0)
        splitFile = splitFile + re.split('</h2>', splitFile[1], 1)
        splitFile.pop(1)
        #extract title
        title = splitFile[1]
        #reconstruct
        output = splitFile[0] + "<h2>" + title + "</h2>" + splitFile[2]

        #add header and footer templates
        output = header + output + footer

        #replace title placeholder with extracted title and title template
        output = output.replace("<!--TITLE-->", title + ", Hayden Shuker")
        os.system('clear')
        print(output)

        #save to file
        outputPathSpecific = open(outputPath + f.name.split("/")[-1], "w")
        outputPathSpecific .write(output)

import os, glob, re

##Inject some text in the middle of a text.
#insertText is inserted at breakText of rawText
#breakText is reinserted after if beforeToggle is
#positive otherwise inserted before
def insertText(rawText, breakText, insertText, beforeToggle):
    t = rawText.split(breakText, 1)
    return t[0] + insertText * beforeToggle +
     breakText + insertText * (not beforeToggle) + t[1]

directory = 'desat/'

#select a page. Use a desaturated file
fileToPush = input("Select post to publish: ") + '.html'

##LOAD FILES
#extract and write title. Use a regular expression to find it burried in h2
f = open(directory + fileToPush)
title = re.search(r"<h2.*?>(?P<title>.*?)</h2>", f.read())['title']
url = 'https://www.haydenshuker.com/'+ fileToPush
f.close()

rss = 'desat/rss.xml'
rssAppendText = '\n<item>\n<title>' + title + '</title>\n '+ '<link>' + url + '</link>\n</item>\n'
rssText = insertText(open(rss).read(),'</channel>', rssAppendText, True)
print(rssText)
if input("save new rss Text? y/N") == "y":
    open(rss, "w").write(rssText)

blog = 'desat/blog.html'
blogAppendText = '</heading>\n\n<article>\n<h2>' + title + '</h2>\n</article>'
blogText = insertText(open(blog).read(), '</heading>', blogAppendText, False)
print(blogText)
if input("save new blog Text? y/N") == "y":
    open(blog, "w").write(blogText)

archive = 'desat/archive.html'
archiveAppendText = '\n<li><a href=\'' + fileToPush + '\'>' + title +'</a></li>'
archiveText = insertText(open(archive).read(), '<h4>2024</h4>\n<ul>', archiveAppendText, False)
print(archiveText)
if input("save new archive Text? y/N") == "y":
    open(archive, "w").write(archiveText)

Future

Now updating the site takes the use of two scripts, plus a some manual copying for the new RSS and other non-HTML files. A completed tool could cut that down to a single combined action. The text splicing code I made could be repurposed for other mass editing actions such as updating hyperlinks and fixing HTML formatting. A similar tool could process my images and other files to decrease file size.

Furthermore, I could make the updater script syndicate to proprietary social media and industrial printing press.

Lessons

Accumulate wisdom and experience rather than codebase.

Permacomputing Principles

Some programming firsts for me were:

• Using regular expressions (more on that later)
• Manipulating files with code
• Running Linux commands with code (just clear screen for now but this could be useful)
• Writing code offline with a downloaded reference text.
• Making an actually useful backend helper tool (I used to make games and toys).
• Thorough code documentation and commenting (for a non school project).

With these I could do some real fundamental IT stuff. My heart is open for more projects.

I cleaned my room. Not an impressive activity but most aren't. I’ve got a whole month to post. Not everyday can be an excursion.

This isn’t an epic moment from a domestic perspective ether. I just took this room from fine to good. If I mopped too that could have been something.

Anyway I’ve been thinking about the room as a shrine. Literally and religiously. I drew this hex sign to ward off evil from my website.

I’m okay with other places having more evil than this room. It proves at least that I’ve done something here. Everyone’s finite power and responsibility and all. I need to find some quality charms and artifacts. No dubious ones sent again by treacherous demons. Engineers have a tendency to take soul damage. I believe this is because WD40 dissolves aether. In any case I must take proper precautions.

I have this tendency to fall into overly formal commercial habits. That's the engineer brain. For example, I keep a set of yearly journals dating back to middle school. They came with spine labels which I used as a library would with years, descriptions, and even myself written in as the author. My ugly handwriting was screaming at me. I don’t need that level of formal archival. These books grew from my body like hair. I know each one in fine temporal detail. These things were my life back in each of their times. So I removed the labels. Now the shelf is a nice series of colors like a weird washed out flag pride flag.