They have no regard for copyright law, generally viewing them as part of a broken system or distractions to (what the pirate librarians might call) their noble goals.

Library Genesis (libgen), Sci-Hub (a superset of libgen) and annas-archive focus primarily on academic materials, textbooks and journal publications. The projects are borne from the goal of allowing access to documents that would normally only be accessible through expensive journals.

Books3 is another pirate library, containing ≈196000 books sourced from Bibliotik. It is named in the spirit of OpenAI's dubiously sourced collections of books, Books1 and Books2. Books3 has become well known for its use in training large language models like LLaMA.

The Internet Archive is pirate library adjacent. It contains and redistributes (without permission) countless copyrighted works, but will respond to takedown requests.

During my time at university, use of Library Genesis and Sci-Hub was rife. While not everyone knew of these sites directly, everyone knew someone who knew someone who did, and textbook PDFs propagated on the sneakernet.

Pirate libraries:

• Library Genesis
• Sci-Hub
• Bibliotik
• Books3
• Gigapedia
• Kolkhoz
• Librusec
• Anna's Archive

An adjacent concept is preservation of media, where pirated copies are seen as a defence against permanent loss. This is the thinking behind the Internet Archive and the sites it has inspired. This kind of thinking is also prevalent in the world of video games, a medium where many works are rendered unavailable by missing online services, changing hardware landscape or lost source code. There are many cases where old games have been recovered or restored through pirated versions.

Web archives:

• Internet Archive
• archive.is
• archive.today

Links

• The Rise of Pirate Libraries
• The Battle Over Books3
• You Can't Stop Pirate Libraries
• The Pirate Library Controversy
• Lost Media Wiki
• Torching the Modern-Day Library of Alexandria (archive.is)
• Visualising all ISBNs
  • And a solution

A link that looks like this feed://notes.zachmanson.com/posts.xml can be clicked on and will open directly a feed aggregator, no matter the origin of the link. This is essentially a subscribe button for the whole internet.

It never made it to official status, and the Wikipedia page listing programs that support it was last updated in 2006. The software cited is NetNewsWire, FeedDemon, Flock, and Safari(‽‽‽‽). Of these, FeedDemon was discontinued in June 2013, Flock was a browser that was discontinued in 2011, Safari support was removed at some point after 2007¹². It also seems that it was tested in Outlook 2007³, but I am unsure if this shipped.

NetNewsWire still exists, is actively supported and is extremely high quality. At the time of writing it is what I use for following feeds. 19 years later, it still supports feed:// links! It works great. I wish this was more common.

I discovered that Pocket Casts, my longtime podcast app⁴ also supports feed:// links, interpreting the link as a podcast feed, though it seemed unable to differentiate podcast feeds from text feeds.

In honour of this I have added a subscribe link to this website!

Normally the advice for creating an app with a layout is to do this in your src/pages/_app.tsx:

// src/pages/_app.tsx

// ... imports go here

export type NextPageWithLayout<P = {}, IP = P> = NextPage<P, IP> & {
  getLayout?: (page: ReactElement) => ReactNode;
};

type AppPropsWithLayout = AppProps & {
  Component: NextPageWithLayout;
};

function App({
  Component,
  pageProps: { session, ...pageProps },
}: AppPropsWithLayout) {
  const getLayout = Component.getLayout ?? ((page) => page);
  return getLayout(
    <SessionProvider session={session}>
      <GlobalProvider>
        <Layout>
          <Component {...pageProps} />
        </Layout>
      </GlobalProvider>
    </SessionProvider>
  );
}

export default App

This works pretty well.

The docs for tRPC suggest wrapping that export:

// src/pages/_app.tsx
import type { AppType } from 'next/app';
import { trpc } from '../utils/trpc';
const MyApp: AppType = ({ Component, pageProps }) => {
  return <Component {...pageProps} />;
};
export default trpc.withTRPC(MyApp);

Combining these seems simple:

// src/pages/_app.tsx

// ... imports go here

export type NextPageWithLayout<P = {}, IP = P> = NextPage<P, IP> & {
  getLayout?: (page: ReactElement) => ReactNode;
};

type AppPropsWithLayout = AppProps & {
  Component: NextPageWithLayout;
};

function App({
  Component,
  pageProps: { session, ...pageProps },
}: AppPropsWithLayout) {
  const getLayout = Component.getLayout ?? ((page) => page);
  return getLayout(
    <SessionProvider session={session}>
      <GlobalProvider>
        <Layout>
          <Component {...pageProps} />
        </Layout>
      </GlobalProvider>
    </SessionProvider>
  );
}

export default trpc.withTRPC(App)

But this will throw a type error

Argument of type '({ Component, pageProps }: AppPropsWithLayout) => ReactNode' is not assignable to parameter of type 'NextComponentType<any, any, any>'.
  Type '({ Component, pageProps }: AppPropsWithLayout) => ReactNode' is not assignable to type 'FunctionComponent<any> & { getInitialProps?(context: any): any; }'.
    Type '({ Component, pageProps }: AppPropsWithLayout) => ReactNode' is not assignable to type 'FunctionComponent<any>'.
      Type 'ReactNode' is not assignable to type 'ReactElement<any, any> | null'.
        Type 'undefined' is not assignable to type 'ReactElement<any, any> | null'.ts(2345)

This is because getLayout returns a ReactNode, the tRPC wrapper expects NextComponentType, which means it expects a ReactElement to be returned?

What's the difference between a ReactNode and a ReactElement?

This StackOverflow post has a great explanation.

A ReactElement is an object with type, props, and key properties:
...
A ReactNode is a ReactElement, string, number, Iterable<ReactNode>, ReactPortal, boolean, null, or undefined:

Géry Ogam

So ReactElement can be cast to ReactNode, but not the other way around.

There is a simple fix. If you move the get layout call inside another React component, it will go back to being a ReactElement.

type AppPropsWithLayout = AppProps & {
  Component: NextPageWithLayout;
};

function App({
  Component,
  pageProps: { session, ...pageProps },
}: AppPropsWithLayout) {
  const getLayout = Component.getLayout ?? ((page) => page);
  const layout = getLayout(
    <Layout>
      <Component {...pageProps} />
    </Layout>
  );
  return (
    <SessionProvider session={session}>
      <GlobalProvider>
        {layout}
      </GlobalProvider>
    </SessionProvider>
  );
}

export default trpc.withTRPC(App)

Lucky I was able to find this tutorial which mentions this exact footgun while I was working on adding tRPC to Penultimate Guitar.

The Error

The type error was being triggered by a chord component, where the key was undefined. The chords are pulled from Ultimate Guitar, so I inspected the JSON payload from the original source.

Why the hell is there a [ch]H[/ch] chord in there? That's definitely the cause as I never accounted for non-existent keys. Looking at Ultimate Guitar, it renders as a B chord.

Huh?

One Google Search Later

Germany and the Netherlands ha(d/ve) their own musical key notation that include(d/s) a H chord. This site claims it ended in "1994/1995", though I've seen other sources claim its still taught this way. This comes as an artefact of the bizarre history Western music notation, which is a problem I seem to keep running into recently in my attempts to learn more about music theory.

I learned in music school that the chord is called "B" (like in the rest of the world), but the note is called "H" (eg. the C Major scale would be C, D, E, F, G, A, H, C).

TobTobXX, who reported the bug

Western Music's Stupid Origins

Western music is based on ecclesiastic modes used in church in the early Middle Ages, which only used the diatonic notes of the C scale (natural notes). The musical notation systems of the time reflected this, not accounting for notes outside of the C scale. When sharps and flats later came into more common use, the existing notation systems needed a way to distinguish them from the natural notes they sat between.

This problem first arose with B natural and B flat, according to the Encyclopedia Britannica. The first method of distinguishing B from B flat was using two different forms of the lowercase "b" character:

Niecks, Frederick. “The Flat, Sharp, and Natural. A Historical Sketch.” Proceedings of the Musical Association, vol. 16, 1889, pp. 79–100.

Somewhere along the line in Germany, monks transcribing these square and round "b" characters confused the squared "b" for "h", and this was later assumed to be intentional. "H" became a convention for writing B natural, while the "b" character remained convention for writing B flat. "B" and "b" became amalgamated, both coming to represent modern B flat.

In the rest of the world, this "H" note didn't catch on.

In time, notation for sharp and flat notes other than B flat was needed. This use of square and round "b" to denote B and B flat eventually evolved into our modern notation for indicating natural and non-natural, accidentals. ♭ comes from the round "b", while ♯ and ♮ come from the square "b".

Somehow, Germany still hasn't fully corrected this mistake, continuing to use "H" to represent B natural in many places. Including Ultimate Guitar. Ugh.

Resolution

I don't love dealing with problems caused by the whims of millennia dead monks, but this was an interesting rabbit hole to fall into. The issue has since been patched, and I look forward to my mistakes ruining someone's day in 3023.

Over the last week I built Alculator using Next.js and hosted on Vercel. The site uses data lovingly freebooted from the Dan Murphy's public API to rank products by the ratio of price to standard drinks, and displaying this data in a card.

The images for these cards are hosted on a Dan Murphy's server (media.danmurphys.com.au), and I am simply using Next.js <Image> tags to point to them.

...
    <div className="card center">
      <div
        className="flex center-aligned"
        onClick={() => (window.location.href = `https://www.danmurphys.com.au/product/${item.stockcode}`)}
      >
        <Image
          alt="Image of drink"
          height="100"
          width="80"
          src={`https://media.danmurphys.com.au/dmo/product/${item.stockcode}-1.png`}
        />
        <div className="fill-width">
          <div className="flex space-between align-center">
            <h3>{item.name}</h3>
...

I'm using Vercel's free tier to serve the application which grants 100GB of bandwidth, which is magnitudes higher than any amount of users I expected to serve. I put the finishing touches on the site on December 30th, sent the link to a few people and went to the pub.

Over the next few hours I started receiving strongly worded alerts from Vercel:

Either I had gone viral or my code was a lot more inefficient than I thought. At 1am I returned home, having reached the Ballmer Peak to diagnose the problem.

On the Vercel/Dashboard/Usage page, right at the bottom is the harmless looking graph titled "Image Optimisations" which turned out to be the culprit. By default, Vercel takes all images hosted in <Image> tags and caches them all at the Edge. Vercel had optimised 1400 of these images before I discovered this and at the free tier this is capped at 1000 images. Whoops.

The solution is simple:

// next-config.js

/** @type {import('next').NextConfig} */
const nextConfig = {
  reactStrictMode: true,
  images: {
    unoptimized: true,
  },
};

module.exports = nextConfig;

Either because

• it's prefixed by "graduate"
• I tricked a floundering company in to hiring me between waves of layoffs for obscene amounts of money
  • more money than most of the people I worked along side who were far smarter than me
  • and who got laid off with me as if we equally deserved it
• I tricked a company into hiring me because they liked my minecraft game (twice)
• software engineers aren't real engineers
• web development isn't even real software engineering
• I couldn't write a compiler if you held me at gun point
• all I do is glue work and waste time
• all I do is build "dashboard for x company to monitor y"
• I don't really understand how half the tools I use work, I just know the buttons I need to press
• when I say "backend" I mean "write db query and write some trivial transformation into JSON"
• when I say "frontend" I mean "tailwind and knowing how React rendering work"
• pipelines are just VendorOps
• I spend all day in baby languages
• all my technical opinions are stolen or surface level
• I feel like I knew more in university even though this is obviously not true
  • I just don't have to write C anymore
• nothing I make has an interesting or novel explanation behind it
• when I say "system administration" I mean "apt install nginx and google"
• when I say "open source" I mean "I chuck my worthless repetitive shit under MIT"
• for every ounce of power and efficiency the laptop I write this on has, my code still runs slow because I am so high up the stack I've never had to see the bottom
• all I do is write tomorrow's legacy code

Obviously much of this is silly and wrong and I'm doing better than most of the people I know, but all I ever do is realise how much higher the Dunning-Kruger rollercoaster ride goes.

Things Australia should steal:

• ubiquitous public transport, underground rail
• street art
• cheap beer
• random very small businesses and bars
• currywurst
• basements
• bike lanes everywhere
• broader bikeshare programs
• circle lines
• density of population
• ground floor is level 0
• miniature versions of city centres in town square
• toilet bowl shape that enables you appreciate your art (shelfstool)
• unique streetnames
• sex clubs, night clubs
• people dressing up and putting effort into costumes for nights out
• no photos in clubs
• paying for public transport with a credit card
• canals
• building being old, interesting architecture
• new venues in old spaces

Things Australia does better:

• comfortable seats on public transport
• cleanliness
• water fountains
• bathrooms
• no toilet attendants
• maccas

https://stackoverflow.com/questions/4230846/what-is-the-etymology-of-slug-in-a-url

https://stackoverflow.com/questions/4230846

This use of the word's use in web media is following a convention from print media, where a "slug" is an informal name given to a story before publication. Print media takes the term from printing presses, where a slug is a line of lead cast characters.

The term slug derives from the days of hot-metal printing, when printers set type by hand in a small form called a stick. Later huge Linotype machines turned molten lead into casts of letters, lines, sentences and paragraphs. A line of lead in both eras was known as a slug.

Kyle Massey

Screenplays have a similar concept, where a "slug line" is a heading at the start of each scene containing important general information about the following scene.

A slug line, also called a master scene heading, occurs at the start of each scene and typically contains 3 pieces of information: whether the scene is set inside or outside (INT. or EXT.; interior or exterior), the specific location, and the time of day. Each slug line begins a new scene. In a "shooting script" the slug lines are numbered consecutively for ease of reference.

Screenplay, Wikipedia

Links

• Slug (publishing), Wikipedia

Abstract

This hEP proposes a framework for adding first-class support for additional forms of h used in mathematical contexts, and that "𝐡" be added to the h programming language standard implementation. As of version 1.0, the only supported output characters are "h" and "'".

Motivation

The h Programming language is borne from the conlang h which was formalised in 2019 by Xe Iaso.

In their unveiling of the language they exhibited how the conlang's simple syntax could be used for complex conversation, all within the use of a single written character and phone:

<Cadey> h
<DoesntGetIt> h h h h
* Cadey facepalms

As stated in h's formal specification, it can be used to represent all possible communications within the confines of the letter h.

They later developed a syntax, compiler and runtime for the h Programming Language (hlang). This programming language was designed for the output of the h conlang, and expanded the character set in use to include both the Romanic form "h" and its Lojbanic equivalent "'".

A long-standing difficulty for the programming language is expressing mathematical notation in its output. While it is entirely possible to express any and all equations in the language, for this purpose it doesn't utiltise the "h" character to its maximum capacity and as such is unnecessarily verbose.

Goals

The primary goals of this proposal are to provide a specification for implementing additional forms of "h" in hlang to enable more terse output for use in mathematical contexts. The only additional form of "h" proposed in this hEP is "𝐡" (U+1D421).

The proposal would enable programs such as this:

$ cat new_equation.h
𝐡 𝐡 h '

AST this would generate during compilation:

H("𝐡 𝐡 h '")

Program output:

𝐡 𝐡 h '

This is an improvement over the existing implementation, which would require the much longer and more cumbersome hlang 1.0 source to produce the equivalent equation:

$ cat old_equation.h
h h h ' ' h ' h h h h h h h h h ' h

Translating this from h (conlang) to English:

a^2 + b^2 = c^2

Non-Goals

This hEP is not an attempt to sully hlang with characters outside of the formal grammar of the h conlang. The scope of the specification, while allowing for additional forms of "h" to be supported, is exclusively for forms of "h". It is not applicable to other characters, such as "g".

This hEP only explicitly proposes the addition of "𝐡" (U+1D421) though is designed to allow other forms of "h" to be supported by hlang in the future, such as "𝒉" (U+1D489), "𝓱" (U+1D4F1), or "𝕙" (U+1D559). While these forms could be implemented in a near identical manner to "𝐡", that is outside of the scope of this hEP. All of these forms of "h" are UTF-8 characters designed for use in mathematical equations.

The hEP is also explicitly not intending to enable support for "h" with diacritics, such as "ḧ" (U+1E27). Etymologically related forms of modern "h" are also outside the scope of this hEP.

Semantics

Under this proposal, "𝐡" would receive first class support by hlang. To output it would be the same as the standard "h" character:

$ cat math_h.h
𝐡

Produced AST:

H(𝐡)

Output:

𝐡

Represented with a node tree:

&peg.Node{
    Name: "H",
    Text: "𝐡",
    Kids: nil,
}

The node tree for the earlier Pythagorean example would be:

&peg.Node{
    Name: "H",
    Text: "𝐡 𝐡 h '",
    Kids: {
        &peg.Node{
            Name: "",
            Text: "𝐡",
            Kids: nil,
        },
        &peg.Node{
            Name: "",
            Text: "𝐡",
            Kids: nil,
        },
        &peg.Node{
            Name: "",
            Text: "h",
            Kids: nil,
        },
        &peg.Node{
            Name: "",
            Text: "'",
            Kids: nil,
        },
    },
}

The "𝐡" character should be usable in all contexts where "h" and "'" are currently usable. Grammatically it should follow all the same principles and restrictions as "h" and "'".

Dependencies

As with hlang v1.0, this proposal not require any dependencies, other than UTF-8 formatted source files.

Acknowledgements

Thanks to Xe Iaso for creating h and hlang, as well as all their other incredible projects.

See also: Dear spotify product manager by Lu Wilson, Redesigning Spotify by Juxtopposed

Unable to Remove DJ Shortcut On Desktop

On desktop they have added a link to the DJ feature at the top of Your Library, below pinned playlists. Despite not being a playlist (nor a feature I use), it continues to appear even when you have set the filter to only show playlists. As far as I know it cannot be removed? But it can be pinned. Despite already being permalocked to the top. The day after writing the previous paragraph, I noticed they added the DJ to the same section in the mobile app. In the mobile app a long press on the DJ icon does shows you an option to hide it, which seems to sync across all my devices. Why is this option not available in the desktop client!

Custom Playlist Sorting

For as long as I can remember you can order the playlists you have created/followed in any order along the left side of the desktop app. You can even put them in nested folders which is fantastic. I have many playlists organised into folders in particular orders. I know how to get to the playlist I want quickly because I have put it in a particular place. This custom order and "Recently played" are the only two i would ever want.

Spotify seems to hate this use case. To my knowledge its never been possible to rearrange order of playlists on the mobile app, only the desktop client.

When you attempt to add a song to playlist on mobile, there isn't even an option to sort by recently played anymore. This is diametrically opposed to desktop, where the right click menu will ONLY allow you to sort by custom order.

Smart Shuffle Button Cycle Lock

Spotify has added a feature called Smart Shuffle that works like normal shuffling, but also adds recommended songs in-between ever few tracks in the queue. On paper I like this feature, though I have never found myself actually using it. I was introduced to it through the following infuriating UX.

I go the the Now Playing screen on the Android Spotify client. The playlist I am listening to is currently set to shuffle (regular shuffle), but I would like to turn off regular shuffle. I press the button with a shuffle icon, which has for 10+ years been a single toggle that would instantly take effect. Instead of a simple 2 option toggle, I find that it has been converted in to a 3 option cycle button, where pressing it cycles through the options of Linear -> Shuffle -> Smart Shuffle -> Linear. I can see the thinking behind this decision, but it breaks muscle memory established all other music players for decades. That is not my issue though.

When you click the button and move the state from Shuffle to Smart Shuffle, the application begins loading the Smart Shuffle recommendations which means it must query Spotify servers, which is an operation that takes multiple seconds. While this occurs, the button with a Shuffle icon becomes a button with a loading spinner, and becomes unclickable. I must wait multiple seconds before I can turn off Smart Shuffle.

Linear -> Shuffle -> Loading (multiple seconds) -> Smart Shuffle -> Linear

This is deeply infuriating. I never even wanted to use Smart Shuffle in the first place and now I must wait for it.

This occurred every time I wanted to turn off Shuffle. Which is a lot.

As of 2024-01-21, this loading state of the button appears to have been removed, thankfully.

Smart Shuffle Cycle Order

Oh sorry did I say the order was Linear -> Shuffle -> Smart Shuffle? Its actually Linear -> Smart Shuffle -> Shuffle. Wait no go back. Wait... it's a different order on my phone vs on desktop? This is real wtf.

Smart Shuffle Popup

I clicked shuffle once and this came up. Thankfully it only ever appeared once on 2023-11-14, but it never should have in the first place.

Overflow Menu Loading

For some godforsaken reason, the overflow menu for a track sometimes appears to require a network request before it can show. If this request is slow, it will show a loading spinner in place of the menu, until the server responds. Or in some cases, the overflow menu will fail to load entirely. This is insane, since for the most part, the options on this menu are identical. This is doubly insane since the menu can load without any issue what-so-ever in offline mode.

I have only ever experienced this issue on the Android mobile app, which for many years did not support swiping on a song to queue a song. At this time you were only able to queue a song. through the overflow menu, which often times meant waiting multiple seconds for menu to appear. God forbid you wanting to queue multiple songs in a row. Thankfully you can now bypass the menu loading by swiping a track to the right.

Oh wait!

Can't Swipe to Queue on Blend Playlists

On Android you cannot swipe to queue a playlist if the playlist is a blend playlist??? Why would this screen use a different component to represent a list of songs to every other screen in the app?

Secret Sliding Menu

This one I only just noticed now while typing this post. There is a sliding menu that appears if you click on your profile picture in the corner of any of the 3 main screens. It seems a bit sparse, like it would be better suited to being a drop down? In any case this menu can actually be accessed from any playlist folder screen as well, despite there being no indication of this. This only seems to work on playlist folder screens though, as it doesn't work for any other subpages.

This one was annoying as I accidentally triggered in when attempting to swipe in from the left to go back a screen.

Can't Swipe Up to Access Player

On Android you can swipe down on the player interface but you cannot swipe up to reveal it. When you attempt this you will almost definitely skip the song that is currently playing, since the minimised version of the player only detects left and right swipes.

Top Bar Alignment

Who the fuck let this happen.

Liked Songs Filters Are Actually a Playlist

For years, if you used the text filter on your Liked Songs and then played one of the songs, the queue would only populate with songs that matched that filter. This could be useful for only listening to a particular artist within your Liked Songs, but was usually just annoying.

As of 2024 it appears this behaviour has been removed.

Search Results Are Actually a Playlist

Similar to the previous issue, if you searched for a song using the search tab, and then played one of the results, the queue would populate with all the other search results meaning you would hear the same song repeated several times, or covers, or random other tracks with similar names.

As of 2024 it appears this behaviour has been removed.

Useless Music Video Indicator

They have added a subtitle and icon for songs with music videos, which looks like it is clickable or has some feature attached to it. But it just... doesn't?

Upcoming Complaints

• Rapidly toggling through Shuffle button states can cause the cycle to desync in strange ways
• Spotify (regular) Shuffle algorithm has some problems

Meta: "MAY I JOIN YOU?"
By David Revoy

One of the oft-touted benefits of the fediverse is that it would be resilient to corporate enshittification. It will be interesting to see how the fediverse handles real threats.

Interesting Articles

Roelant Kooij wrote an excellent overview of the arguments on either side of this debate. The Fediverse Report also has a good timeline of the news. These are sorted in the order I have found them, with my strongest recommendations in bold.

• Not That Kind of ‘Open’, John Gruber on the debate
  • suggests that the pre-emptive block may be "petty and deliberately insular"
• More on Preemptively Blocking Facebook’s Imminent ActivityPub Entry, John Gruber's follow-up
  • suggests that if Facebook is federated, they should start with "two strikes against it"
  • "Is the goal of the Fediverse to be anti-corporate/anti-commercial, or to be pro-openness? I think openness is the answer"
• How to Kill a Decentralised Network (such as the Fediverse), Ploum's excellent writeup on how large companies can (sometimes maliciously) kill open/decentralised networks
  • makes comparison to Google killing XMPP and Microsoft using OOXML to cripple open source office software
• ⭐️ Meta on the Fediverse: to block or not to block?, SciComm admins writeup of their balanced thought process on pre-emptive blocking
  • they conclude to pre-emptively block, but leave the door open to unblocking if Meta is a decent fediverse citizen
• Why would Meta implement ActivityPub? 1½ reasons are compelling, another is not, Johannes Ernst's analysis of Meta's motivations
  • suggests EEE is not worthwhile for Meta, far less important than appeasing incoming EU regulations
• Tim Chamber's (indieweb.social admin) First Time? series of posts on the matter
  • Project92 and the Fediverse - A Smarter Battle Plan to Protect the Open Social Web
    • suggests that pre-emptive defederation is not the most effective strategy to protect the current fediverse
    • thinks current fediverse can win by providing a better experience, especially in areas where corporate interests conflict with this (e.g. advertising)
  • Project92, the Fediverse: (First Time? Part 2)
    • 'We have the tools to protect our people, and we are stronger to "Watch like a hawk, with our fingers over the block button."'
  • Meta and the Fediverse (First Time? Part 3)
    • generally calling for calming of vitriol, promoting compassion between disagreeing groups
    • "All sides should admit we don’t know far more than we do know right now."
  • Instagram Threads and the Fediverse (First Time? Part 4), a summation of all his previous posts
• ⭐️ The Two Camps of Mastodon, on the general split between people that view the fediverse as a collection of small communities and those that view it as a distributed network where most people can talk to most others in a decentralised fashion, and how Threads' existence exacerbate this divide
• The horns of a dilemma, Wendy M. Grossman enumerating potential futures
• ⭐️ Meta and the fediverse: sorting heat from light, a fantastic rebuke to many of Meta's alleged nefarious motivations
  • meta gains little in terms of data collection ability since ActivityPub lacks privacy anyway, and what it does gain isn't very useful, and the current fediverse population size is not large enough to be worth pursuing for data collection
  • its seems unlikely that Meta actually sees the fediverse as a threat
  • the Gchat/XMPP embrace/extend/extinguish example is flawed
  • Meta isn't evil without motivation
  • "So why is Meta going to use ActivityPub? Here’s the thing; I haven’t the faintest fucking clue. It does not obviously help Meta in any way to have interoperability with ActivityPub"
• You’re So Vain, You Probably Think This App Is About You, an argument against the idea that Meta actually wants to EEE the fediverse
  • suggests that there is little monetary reason to federate from Meta's perspective, other than regulatory pressure
  • particularly posits that defederating from servers that refuse to defederate Meta is particularly short-sighted

It is such a devastating attack that it's crazy nobody in-universe has tried it before, especially given the existence of autonomous robots that can operate ships. The film provides no counter to this attack. It's not unreasonable to wonder what kind of impact this style of attack could have had on the Death Star.

The Last Jedi film doesn't provide any explanation for why this has never been tried before. The novelisation has an explanation, stating the the Raddus has experimental shields allowing it to do this, but this is not in the text of the film at all. Further, it is contradicted in The Rise of Skywalker's attempted explanation which states that the "Holdo Maneuver" was "one in a million". That explanation feels unsatisfactory to me, because it mean that Holdo either:

1. was extremely lucky and noticed that the conditions were just right for it to work so went for it
2. was risking everything when the attack was extremely unlikely to work

Neither of those explanations seem to line up with the way it is portrayed in The Last Jedi. The idea that the Holdo Maneuver is extremely rare doesn't seem to make sense even within the context of The Rise of Skywalker, given that:

1. another Holdo Maneuver is shown at the end of the movie above the moon of Endor
2. the battle on Exegol seems like the perfect set up for a Holdo Maneuver, with thousands of Final Order capital ships, extremely close together

The Last Jedi itself is excruciatingly close to a sensible explanation that works in-universe: you can only lightspeed ram a ship that is attempting to track you through hyperspace.

The more I think about this the more sense it makes.

This places an interesting limit both mechanics introduced in The Last Jedi. By tracking a ship through hyperspace, you are opening yourself up to a potentially devastating attack, but an attack that likely will cost the enemy heavily too. If your enemy suspects that you're going to ram them, they can turn off their hyperspace tracking equipment, which protects them but may allow you an opportunity to escape.

It also creates a logical reason why a droid-piloted lightspeed ram wouldn't have worked in The Last Jedi, since it is well established that ships can be scanned for the presence of lifeforms. Your enemy could detect that your ship has no lifeforms aboard, surmise you are planning on ramming them, giving them the opportunity to counter.

The pseudoscience of how this works could be easily explained, even within limited explanation that hyperspace has in Star Wars.

A Resistance engineer (perhaps named Rose) hurriedly pushes past officers on the bridge, panting as she reaches Admiral Holdo. A sergeant begins to berate her for forcing her way onto the bridge but he is put at ease by the Admiral. Holdo asks the engineer what's so important it warrants the commotion.

"If they're tracking us through hyperspace, their ship must be in normal space and hyperspace at the same time" says the engineer as she catches her breath.

Holdo's expression drops. She pauses, eyes calculating. What the engineer is intimating has never been done before. The room is silent.

Holdo snaps back to reality, ordering the bridge be cleared and the ship evacuated.

This cleanly explains why this has never been done before, it wasn't possible until hyperspace tracking was developed. This battle will have implications for all future battles, where any ship capable of hyperspace tracking introduces the possibility mutually assured destruction

Alas, what could have been.

Every time I begin to write for this site, I open Codium and create a new file in my repo. Then I realise I meant to create a new folder, call myself an idiot and start over. This is the first step of my process, which currently concludes with running my anemic static site generator. I hope to soon replace with this a bespoke and iron proficient(?) site generator, but until then I will continue using Pandoc to fulfill my static site generator requirements.

My static site generator requirements:

• Markdown input
• Code highlighting
• with theming?
• Simple templating
• Minimum (ideally 0) dependencies
• Automated?

Markdown Input

It can convert documents between myriad formats, most relevantly Markdown to HTML.

pandoc inputfile.md -o output.html --to=html5

Code Highlighting

There are plenty of tools that can do this, but Pandoc was the first I found that had code highlighting without having any depedencies like highlight.js, just saving the colour information in inline CSS

Any fenced Markdown code blocks with a language specified (like the following) will have the syntax automatically highlighted by Pandoc.

# Title

## Subtitle

Lorem ipsum amirite.  Hey look a fenced code block:

```Python
if x == 5:
    print("x is equal to 5")
```

Pandoc will turn this Markdown into the following HTML:

<h1 id="title">Title</h1>
<h2 id="subtitle">Subtitle</h2>
<p>Lorem ipsum amirite. Hey look a fenced code block:</p>
<div class="sourceCode" id="cb3"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> x <span class="op">==</span> <span class="dv">5</span>:</span>
<span id="cb3-2"><a href="#cb3-2" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">"x is equal to 5"</span>)</span></code></pre></div>

The various HTML tag class spaghetti are used to highlight the code, though the CSS required to actually make this work is not included in the standard Pandoc command invocation. To actually generate the CSS that makes these classes work you need to use the --standalone flag, à la:

pandoc inputfile.md -o output.html --to=html5 --standalone

This will include some inline CSS, along the lines of:

code span.al { color: #ff0000; font-weight: bold; } /* Alert */
code span.an { color: #60a0b0; font-weight: bold; font-style: italic; } /* Annotation */
code span.at { color: #7d9029; } /* Attribute */
code span.bn { color: #40a070; } /* BaseN */
code span.bu { } /* BuiltIn */
code span.cf { color: #007020; font-weight: bold; } /* ControlFlow */
code span.ch { color: #4070a0; } /* Char */
code span.cn { color: #880000; } /* Constant */
code span.co { color: #60a0b0; font-style: italic; } /* Comment */
code span.cv { color: #60a0b0; font-weight: bold; font-style: italic; } /* CommentVar */
code span.do { color: #ba2121; font-style: italic; } /* Documentation */
code span.dt { color: #902000; } /* DataType */
code span.dv { color: #40a070; } /* DecVal */
code span.er { color: #ff0000; font-weight: bold; } /* Error */
code span.ex { } /* Extension */
code span.fl { color: #40a070; } /* Float */
code span.fu { color: #06287e; } /* Function */
code span.im { } /* Import */
code span.in { color: #60a0b0; font-weight: bold; font-style: italic; } /* Information */
code span.kw { color: #007020; font-weight: bold; } /* Keyword */
code span.op { color: #666666; } /* Operator */
code span.ot { color: #007020; } /* Other */
code span.pp { color: #bc7a00; } /* Preprocessor */
code span.sc { color: #4070a0; } /* SpecialChar */
code span.ss { color: #bb6688; } /* SpecialString */
code span.st { color: #4070a0; } /* String */
code span.va { color: #19177c; } /* Variable */
code span.vs { color: #4070a0; } /* VerbatimString */
code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } /* Warning */

This CSS is great, but only actually needs to be generated once. I copied this CSS in a single file. After copying this text, the --standalone flag can be omitted.

with theming?

The colours used in the highlighting can be customised! As with everything else in my life at the moment, I use Dracula, which thankfully already has a theme for Pandoc.

Once the theme is installed, Pandoc can highlight using the theme with the --defaults flag:

pandoc inputfile.md -o output.html --to=html5 --standalone --defaults path/to/theme/dracula.yaml

The HTML classes will be the same names regardless of the theme, but the inline CSS will be dependent on the theme. Again, this only needs to be run once, and the inline CSS can be copied and saved to be used later.

Simple Templating

Pandoc makes it simple, as long as you only need simple template insertions! HTML templates can be created easily. A basic template could look like the following:

<!DOCTYPE html>
<head>
    <link rel="stylesheet" href="/styles/code.css">
    <title>$title$</title>
</head>

<body>
    <header>
        <h1>$title$</h1>
        <p>$subtitle$</p>
        <p>$date$</p>
    </header>

    <article>
        $body$
    </article>
</body>

Note the inclusion of the stylesheet. code.css includes the CSS for code highlighting.

The body variable is automatically assigned to the content of the Markdown file, and the rest of the variables can be assigned manually using a YAML header in the Markdown file.

---
title: A Titular Title
subtitle: A subtitular subtitle
date: 2022-06-12
---

## Chapter 1: Where it all began

Lorem ipsum amirite.  Hey look a fenced code block:

```Python
if x == 5:
    print("x is equal to 5")
```

To use the template, you use the --template flag in the Pandoc invocation:

pandoc inputfile.md -o outputfile.html --to=html5 --template=path/to/template.html

Dependencies

None! The outputted HTML has no external dependencies.

Automated?

It's a pain typing out that command for each post - so don't.

#!/usr/bin/env bash

nonposts=("styles/", "templates/")

for d in */; do
    echo "$d"
    if ! [[ ${nonposts[*]} =~ $d ]]; then
        echo "is post"
        echo "generating index.html"
        name=$(echo "$d" | sed 's/.$//')
        echo "pandoc ${d}${name}.md -o ${d}index.html --to=html5 --template=templates/template.html"
        pandoc ${d}${name}.md -o ${d}index.html --to=html5 --template=templates/template.html
    fi
done
echo "done"

This script is designed to work on the following directory structure:

blog
├── basic-seleniumbasic
│   ├── adding-reference.png
│   ├── basic-seleniumbasic.md
│   ├── dotnet-frameworks.png
│   ├── index.html
│   └── seleniumbasic-installer.png
├── covid-updates
│   ├── covid-updates.md
│   ├── index.html
│   └── media_release.png
├── crafting-recipes
│   ├── crafting-recipes.md
│   └── index.html
├── file-descriptors
│   ├── file-descriptors.md
│   └── index.html
├── generate_posts.sh
├── hep-001
│   ├── hep-001.md
│   └── index.html
├── index.html
├── poor-mans-site
│   ├── index.html
│   └── poor-mans-site.md
├── templates
│   └── template.html
└── usernames
    ├── index.html
    └── usernames.md

It opens every directory (except those in nonposts), runs pandoc on a Markdown file with the same name as the directory, and outputs index.html based on templates/template.html.

The top level index.html is not modified by the script at all. This page presumably would link to the subdirectories and must be manually modified. Ugh.

Once you submit a prompt to DALL-E, you are shown more curated images and their corresponding prompts while your request is processed.

DALL-E is capable of producing some amazing images. It takes a bit of warming up, but after little practice I was able to create wonderful and bizarre generative art. Despite this, I felt I didn't know how to produce something as interesting or engaging as their curated images the presented to me when using DALL-E. I could logically understand that the tool had potential, but I felt separated from it.

Using Midjourney is completely a different experience. Midjourney currently runs its generative art AI through a bot on their company Discord server. You generate images by typing in a command in certain channels, and all the images produced are visible to everyone on the server simultaneously. Before you can even type something you are assaulted by an unfiltered, non-curated array of incredible images, all diffusing right before your eyes.

While both generators are impressive, using Midjourney was a visceral experience for me in a way that DALL-E was not. DALL-E is sipping a glass of water, Midjourney is a firehose blasting your face. I was immediately in awe.

The design of Midjourney makes it abundantly clear how big an impact this technology will have on the world. Watching hundreds of strangers generate images in real-time is jaw dropping. I was mesmerised, and within minutes saw images that moved me, despite being created by an AI without any intention behind them.

While I am sure both of these are the future, only one made me feel it.

There's no way of knowing that your last good day is Your Last Good Day. At the time, it is just another good day.

The story presents this in the context of Augustus' worsening condition and eventual death.

So far, I've been lucky enough to be free of facing slow health declines in myself and those close to me, but the concept of the Last Good Day has sat quietly in the back of my mind since first encountering it. Whenever I have some kind of impending loss, no matter how small, my thoughts tend to orbit around it.

With my bachelor's degree coming to a close soon, lots of my friends are moving away for careers or further study in other countries. The groups that have formed won't continue to exist in the way the have for the last 3 years. Not everyone is leaving of course and no one person is single load-bearing pillar of the group, but buildings tend not to handle losing half their supports.

I've been aware that this will happen for months, and at every group event in my head I'm constantly thinking Is this going to be the Last Good Day? Is this Good enough? Can I make this better? This is definitely not healthy and definitely doesn't help me enjoy the limited time left with my friends. This line of thinking is something I hesitate to even talk about with my friends in fear of inspiring the same kind of thought spirals in their minds.

Time has gone on and the erosion has begun. As I write this, another will be flying to Sydney tomorrow morning. Enough friends have left now that the Last Good Day has certainly passed, and yet I'm still not 100% sure which day it was. There's some strong contenders though.

That's life, I know I'll make more friends and there's no need to be melodramatic. Regardless, I'm going to miss this period and the people I've spent it with.

Cheers and auld lang syne and so on.

The meeting was very preliminary, essentially just getting to know one another and bounce some ideas off each other. One idea I had been mulling over was "Wordle but with for Minecraft crafting recipes", which requires no explanation for players of these two games (which among my peers includes everyone). My group immediately latched onto the idea, but acknowledged the scope of including all Minecraft recipes would be challenge, both in terms of game design and actually acquiring them.

Transcribing by hand was possible but likely impractical, as was automatically scraping the wiki. Luckily, the thousands of modders before us had poured through Minecraft's source file and through cursory googling we were able to get to .minecraft/versions/1.18.1.jar/data/minecraft/recipes/, where all crafting recipes in the game are stored as lovely little JSON files. Perfect!

Upon further inspection there are some mildly interesting quirks within these JSON files. The majority of recipes vaguely follow this format:

{
  "type": "minecraft:crafting_shaped",
  "pattern": ["###", "#X#", "#R#"],
  "key": {
    "R": {
      "item": "minecraft:redstone"
    },
    "#": {
      "item": "minecraft:cobblestone"
    },
    "X": {
      "item": "minecraft:bow"
    }
  },
  "result": {
    "item": "minecraft:dispenser"
  }
}

Seems like a straightforward and logical way of laying it all out. Presumably the "type" being "crafting_shaped" is to denote recipes with particular shapes (like a dispenser) as different from recipes where block arrangement doesn't matter (like mushroom stew).

Shapeless crafting recipes follow a simpler format:

{
  "type": "minecraft:crafting_shapeless",
  "ingredients": [
    {
      "item": "minecraft:brown_mushroom"
    },
    {
      "item": "minecraft:red_mushroom"
    },
    {
      "item": "minecraft:bowl"
    }
  ],
  "result": {
    "item": "minecraft:mushroom_stew"
  }
}

The recipes folder contains a lot more than two types though:

zach@grannysmith recipes % awk 'FNR == 2' *.json | sort | uniq -c
  24   "type": "minecraft:blasting",
   9   "type": "minecraft:campfire_cooking",
 543   "type": "minecraft:crafting_shaped",
 183   "type": "minecraft:crafting_shapeless",
   1   "type": "minecraft:crafting_special_armordye"
   1   "type": "minecraft:crafting_special_bannerduplicate"
   1   "type": "minecraft:crafting_special_bookcloning"
   1   "type": "minecraft:crafting_special_firework_rocket"
   1   "type": "minecraft:crafting_special_firework_star"
   1   "type": "minecraft:crafting_special_firework_star_fade"
   1   "type": "minecraft:crafting_special_mapcloning"
   1   "type": "minecraft:crafting_special_mapextending"
   1   "type": "minecraft:crafting_special_repairitem"
   1   "type": "minecraft:crafting_special_shielddecoration"
   1   "type": "minecraft:crafting_special_shulkerboxcoloring"
   1   "type": "minecraft:crafting_special_suspiciousstew"
   1   "type": "minecraft:crafting_special_tippedarrow"
  70   "type": "minecraft:smelting",
   9   "type": "minecraft:smithing",
   9   "type": "minecraft:smoking",
 198   "type": "minecraft:stonecutting",

Hold on, that's not just crafting recipes! All kinds "recipes" are stored in this directory, from normal smoking to smithing. This explains the repeated entries for items like cooked porkchop.

zach@grannysmith recipes % ls cooked*.json
cooked_beef.json                           cooked_mutton_from_smoking.json
cooked_beef_from_campfire_cooking.json     cooked_porkchop.json
cooked_beef_from_smoking.json              cooked_porkchop_from_campfire_cooking.json
cooked_chicken.json                        cooked_porkchop_from_smoking.json
cooked_chicken_from_campfire_cooking.json  cooked_rabbit.json
cooked_chicken_from_smoking.json           cooked_rabbit_from_campfire_cooking.json
cooked_cod.json                            cooked_rabbit_from_smoking.json
cooked_cod_from_campfire_cooking.json      cooked_salmon.json
cooked_cod_from_smoking.json               cooked_salmon_from_campfire_cooking.json
cooked_mutton.json                         cooked_salmon_from_smoking.json
cooked_mutton_from_campfire_cooking.json

Smelted items have an even simpler format:

{
  "type": "minecraft:smelting",
  "ingredient": {
    "item": "minecraft:porkchop"
  },
  "result": "minecraft:cooked_porkchop",
  "experience": 0.35,
  "cookingtime": 200
}

Puzzingly there is a value for cooking time for each item, though smelting time is dependent on the type of furnace used rather than the item being smelted.

For example, all items cooked in a blast furnace have the same value for cooking time:

zach@grannysmith recipes % cat *blast* | grep "cookingtime"
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100
  "cookingtime": 100

It could be to accommodate varying smelting times in the future, but for the moment this seems redundant.

All of the special crafting recipes aren't stored at all, which makes sense since these are more complex than what should be written in a single JSON file.

zach@grannysmith recipes % cat $(grep -lr . -e "special")
{
  "type": "minecraft:crafting_special_bookcloning"
}{
  "type": "minecraft:crafting_special_firework_star_fade"
}{
  "type": "minecraft:crafting_special_firework_rocket"
}{
  "type": "minecraft:crafting_special_shulkerboxcoloring"
}{
  "type": "minecraft:crafting_special_mapcloning"
}{
  "type": "minecraft:crafting_special_repairitem"
}{
  "type": "minecraft:crafting_special_bannerduplicate"
}{
  "type": "minecraft:crafting_special_armordye"
}{
  "type": "minecraft:crafting_special_tippedarrow"
}{
  "type": "minecraft:crafting_special_firework_star"
}{
  "type": "minecraft:crafting_special_mapextending"
}{
  "type": "minecraft:crafting_special_shielddecoration"
}{
  "type": "minecraft:crafting_special_suspiciousstew"
}

Tools smithed with netherite get a different and simple format as well:

> cat netherite_sword_smithing.json
{
  "type": "minecraft:smithing",
  "base": {
    "item": "minecraft:diamond_sword"
  },
  "addition": {
    "item": "minecraft:netherite_ingot"
  },
  "result": {
    "item": "minecraft:netherite_sword"
  }
}

Stonecutting unveiled an interesting quirk:

> cat chiseled_stone_bricks_stone_from_stonecutting.json
{
  "type": "minecraft:stonecutting",
  "ingredient": {
    "item": "minecraft:stone"
  },
  "result": "minecraft:chiseled_stone_bricks",
  "count": 1
}

The count value determine how many items are output by the recipe, and appears in over 579 total recipes. For the standard crafting recipes this value only appears for recipes that output more than 1 item, but curiously stonecutter recipes always include this value.

All this elicited a nose exhale and an "oh neat" from me as I poked around the files. Most of these details aren't important to the project, but the parts that are important will be a huge time save. Web scraping in my experience is a pain (though somehow I think the maintainers of the Minecraft wiki would be more consistent than the WA Government).

Now we can focus on the real trouble - every other aspect of puzzle game design and web development. I am particularly not looking forward to dealing with the interaction between Wordle-style position hints and different crafting orientation/positions.

Update 2022-06-05:

Minecraftle is playable and nearly fully finished. We submitted two weeks ago but there are a few things I want to implement for my own interest. The JSON files discussed in this post were used, but their format was inconvenient for querying so needed to be restructured. Yesterday I rewrote the script to restructure the recipe JSON files since the initial version was a mess, and finally implemented the functions to validate recipes on object placement. These changes revealed a few more quirks in the recipe JSON files.

Some recipes have multiple forms, such as torches which use coal or charcoal. I had assumed this would just result in two seperate recipe files, but:

> cat torch.json
{
  "type": "minecraft:crafting_shaped",
  "pattern": [
    "X",
    "#"
  ],
  "key": {
    "#": {
      "item": "minecraft:stick"
    },
    "X": [
      {
        "item": "minecraft:coal"
      },
      {
        "item": "minecraft:charcoal"
      }
    ]
  },
  "result": {
    "item": "minecraft:torch",
    "count": 4
  }
}

This actually caused a mild issue in Minecraftle that I currently have a hacky solution for. As far as I can tell this doesn't appear in many recipes (though I'm too lazy to write the regex to check). When we restructure the JSON files, we simplify the format so the pattern field contains the actual item names rather than character representations. This doesn't leave much room alternate forms, short of just repeating the whole recipe with the differing items. While totally possible, I just forced it to select the first item whenever there are multiple options. This means that you would be unable to craft a torch with charcoal.

As far as I can tell this poses no issues since in Minecraftle's current form you don't receive charcoal as a crafting ingredient, and I am yet to find another appearance of this format that uses the items in given_ingredients.json. I'm still uncomfortable with this though, and I hope to come back and fix it after exams.

Another oddity reared its head with stone tools:

> cat stone_axe.json
{
  "type": "minecraft:crafting_shaped",
  "pattern": [
    "XX",
    "X#",
    " #"
  ],
  "key": {
    "#": {
      "item": "minecraft:stick"
    },
    "X": {
      "tag": "minecraft:stone_tool_materials"
    }
  },
  "result": {
    "item": "minecraft:stone_axe"
  }
}

See it? tag replaces item in a number of cases, such as stone tools. Blackstone and cobbled deepslate have been added fairly recently to the game, and can be used for interchangably for cobblestone in a number of recipes. This kind of notation appears in a number of recipes:

> grep  "\"tag\":" *
acacia_planks.json:      "tag": "minecraft:acacia_logs"
barrel.json:      "tag": "minecraft:planks"
barrel.json:      "tag": "minecraft:wooden_slabs"
beehive.json:      "tag": "minecraft:planks"
birch_planks.json:      "tag": "minecraft:birch_logs"
black_bed.json:      "tag": "minecraft:planks"
blue_bed.json:      "tag": "minecraft:planks"
bookshelf.json:      "tag": "minecraft:planks"
bowl.json:      "tag": "minecraft:planks"
brewing_stand.json:      "tag": "minecraft:stone_crafting_materials"
brown_bed.json:      "tag": "minecraft:planks"
campfire.json:      "tag": "minecraft:logs"
campfire.json:      "tag": "minecraft:coals"
cartography_table.json:      "tag": "minecraft:planks"
chest.json:      "tag": "minecraft:planks"
composter.json:      "tag": "minecraft:wooden_slabs"
crafting_table.json:      "tag": "minecraft:planks"
crimson_planks.json:      "tag": "minecraft:crimson_stems"
cyan_bed.json:      "tag": "minecraft:planks"
dark_oak_planks.json:      "tag": "minecraft:dark_oak_logs"
daylight_detector.json:      "tag": "minecraft:wooden_slabs"
fletching_table.json:      "tag": "minecraft:planks"
furnace.json:      "tag": "minecraft:stone_crafting_materials"
gray_bed.json:      "tag": "minecraft:planks"
green_bed.json:      "tag": "minecraft:planks"
grindstone.json:      "tag": "minecraft:planks"
jukebox.json:      "tag": "minecraft:planks"
jungle_planks.json:      "tag": "minecraft:jungle_logs"
lectern.json:      "tag": "minecraft:wooden_slabs"
light_blue_bed.json:      "tag": "minecraft:planks"
light_gray_bed.json:      "tag": "minecraft:planks"
lime_bed.json:      "tag": "minecraft:planks"
loom.json:      "tag": "minecraft:planks"
magenta_bed.json:      "tag": "minecraft:planks"
note_block.json:      "tag": "minecraft:planks"
oak_planks.json:      "tag": "minecraft:oak_logs"
orange_bed.json:      "tag": "minecraft:planks"
painting.json:      "tag": "minecraft:wool"
pink_bed.json:      "tag": "minecraft:planks"
piston.json:      "tag": "minecraft:planks"
purple_bed.json:      "tag": "minecraft:planks"
red_bed.json:      "tag": "minecraft:planks"
shield.json:      "tag": "minecraft:planks"
smithing_table.json:      "tag": "minecraft:planks"
smoker.json:      "tag": "minecraft:logs"
soul_campfire.json:      "tag": "minecraft:logs"
soul_campfire.json:      "tag": "minecraft:soul_fire_base_blocks"
soul_torch.json:      "tag": "minecraft:soul_fire_base_blocks"
spruce_planks.json:      "tag": "minecraft:spruce_logs"
stick.json:      "tag": "minecraft:planks"
stone_axe.json:      "tag": "minecraft:stone_tool_materials"
stone_hoe.json:      "tag": "minecraft:stone_tool_materials"
stone_pickaxe.json:      "tag": "minecraft:stone_tool_materials"
stone_shovel.json:      "tag": "minecraft:stone_tool_materials"
stone_sword.json:      "tag": "minecraft:stone_tool_materials"
tripwire_hook.json:      "tag": "minecraft:planks"
warped_planks.json:      "tag": "minecraft:warped_stems"
white_bed.json:      "tag": "minecraft:planks"
wooden_axe.json:      "tag": "minecraft:planks"
wooden_hoe.json:      "tag": "minecraft:planks"
wooden_pickaxe.json:      "tag": "minecraft:planks"
wooden_shovel.json:      "tag": "minecraft:planks"
wooden_sword.json:      "tag": "minecraft:planks"
yellow_bed.json:      "tag": "minecraft:planks"

These tags are referring to .minecraft/versions/1.18.1.jar/data/minecraft/tags/items/, which holds yet more JSON files with lists of all items that belong to each tag. For example:

> cat stone_crafting_materials.json
{
  "replace": false,
  "values": [
    "minecraft:cobblestone",
    "minecraft:blackstone",
    "minecraft:cobbled_deepslate"
  ]
}

To deal with these I've currently just put edge cases in to handle these tags manually, though I would like to have a more robust solution in the future that can be determined by given_ingredients.json.

Both of these appear to be solving the same problem, and it's strange that coal doesn't use the tag field, especially since there is tag JSON file that seems made for this:

> cat coals.json
{
  "replace": false,
  "values": [
    "minecraft:coal",
    "minecraft:charcoal"
  ]
}

I theorize that the torch was older method of achieving this goal and just hasn't been updated to use the new system (though I am again too lazy and won't check old versions), unless there is some other difference I am not aware of between the two methods. Maybe I should send Mojang a pull request.

Recipe validation was the final feature I really felt was necessary for my own sense of completion. That said, we never added shapeless recipe support... or varying difficulties... or hardcore mode. Oh well.

RTK Query with React is pretty great! The primary pattern you find yourself using with it is:

1. writing a small API definition that provides
   1. the endpoint url
   2. type definitions for request args and response schema
   3. (usually) simply logic for converting passed argument type into request params/body
   4. (usually) simple logic for converting response payload into the response schema
2. importing a hook that RTK Query automatically generates for you
3. reuse the same hook across multiple components

RTK Query handles loading states, stale while revalidate states, error states, type safety, and caching.

When writing React components, the caching is the most impactful of these. You can just call the same hook in many different components, and as long as the params are the same the same it will only be a single network request. This removes the need for many invocations useState and Redux state calls, since you can just feign a call to the backend every time you need that data.

There is a little boilerplate you have to write, but the meat of a basic RTK Query definition will look something like this:

    getLocation: build.query<Location, { id: number }>({
      query: ({ ids }) => ({
        url: "api/v1/location",
        params: { id },
      }),
      transformResponse: (response: any) => response.data,
    }),

This will generate a hook called useGetLocation which will be cached. Suddenly you never need to store a Location object in state to share it across components and you can just call useGetLocation({id:5}) every time you need it. It also provides a lazy version of the hook that returns a normal function you can use to retrieve the data, which is good for APIs that need to be called multiple times.

function LocationCard({ id }: {id: number}) {
    const {data: location, isLoading} = useGetLocation({id:id});
    const [getLocationsLazy] = useLazyGetLocation();
    ...
    return (
        <div>
            {location.address}
        </div>
    );
}

For straightforward GET requests this pattern stellar. RTK Query encourages you to put all the API definitions into a single file (src/api/api.ts), or into a small number files with particular scopes. For small-medium applications this works well, if you know the URL of an endpoint you want to hit you can just search within the api.ts file, use the accompanying hook and you are good to go, type safety and all. I'm sure this single file approach would breakdown for big applications but its very pleasant at smaller scales.

RTK Query also lets you do POST/PUT/PATCH requests with a similar definition style. Instead of using build.query, you use build.mutation.

    addLocation: build.mutation<
      { location_id: number; site_id: number; address: string; abn: string; user_id: number },
      NewLocation
    >({
      query: (body) => ({
        url: "api/v1/location",
        method: "POST",
        body: body,
      }),
    }),
    patchLocation: build.mutation<void, { id: number; data: Partial<Location> }>({
      query: ({ id, data }) => {
        return {
          method: "PATCH",
          url: `api/v1/location/${primaryKey}`,
          body: data,
        };
      },
      transformResponse: (response: any) => response.data,
    }),

The hooks generated here will return a function that can be used to send requests.

function LocationCard({id}: {id:number}) {
    const {data: location, isLoading} = useGetLocationQuery({id:id})
    const [patchLocation, isPatchLoading] = usePatchLocationMutation()

    function onUpdate(locationUpdate:Partial<Location>) {
        patchLocation(locationUpdate)
    }
    ...
    return (
        <div>
            {location.address}
            ...
            {/* some input that calls onUpdate on change */}
        </div>
    )
}

But wait! If I patch a location, how will the useGetLocation hook know that it's cache is invalid?

Cache Invalidation

RTK Query uses a tag system for cache invalidation, where a tag represents a kind of query. Queries can assign themselves tags, and mutations can provide a list of tags they will invalidate.

These can be static

    getLocation: build.query<Location, { id: number }>({
      query: ({ ids }) => ({
        url: "api/v1/location",
        params: { id },
      }),
      transformResponse: (response: any) => response.data,
      providesTags: ['Location'],
    }),

or dynamic, based on the params given

    getLocation: build.query<Location, { id: number }>({
      query: ({ ids }) => ({
        url: "api/v1/location",
        params: { id },
      }),
      transformResponse: (response: any) => response.data,
      providesTags: (result, error, arg) => [{type:"Location", id: id}]
    }),

And similarly for mutations

    patchLocation: build.mutation<void, { id: number; data: Partial<Location> }>({
      query: ({ id, data }) => {
        return {
          method: "PATCH",
          url: `api/v1/location/${primaryKey}`,
          body: data,
        };
      },
      transformResponse: (response: any) => response.data,
      invalidatesTags: (result, error, arg) => [{ type: 'Location', id: arg.id }] // or just ["Location"] to invalidate the whole category
    }),

Where you can, dynamic tags are generally better since you have much more granular control. Again, this works pretty well for straightforward queries.

Pagination

RTK Query doesn't include a mechanism for paging data, but passing a page number as a param works fine if you have discrete pages.

    getLocations: build.query<Location, { page: number }>({
      query: ({ page }) => ({
        url: "api/v1/locations",
        params: { page }
      }),
      transformResponse: (response: any) => response.data,
      providesTags: (result, error, arg) => [...result.map(location => {type:"Location", id: location.id}), {type:"Location", id: "LIST"}],
    }),

But what about infinite scroll?

When infinitely scrolling, normally you'd have an array that stores all the results that have been loaded so far, and then you'd append new results to the end of this list when they are loaded in (maybe even dropping some entries from the start if you are memory constrained). The hook generated by the previous example will only ever let you access one page's entries at a time.

RTK Query doesn't have any special functions for infinite scrolling, but the pieces it gives you are enough to make it work. When writing a query definition you can explicitly set which params contribute are used to define unique cache entries, and another function to say how old cache entries should be overwritten by new ones.

    getLocations: build.query<Location, { page: number }>({
      query: () => ({
        url: "api/v1/locations",
        params: { page }

      }),
      transformResponse: (response: any) => response.data,
      providesTags: (result, error, arg) => [...result.map(location => {type:"Location", id: location.id}), {type:"Location", id: "LIST"}],

      // overwrite cached value when page value changes, treat page
      serializeQueryArgs: ({ queryArgs }) => ({ ...queryArgs, page: undefined }),

      // when overwriting cache value, append new data to old list
      merge: (currentCache, newData, otherArgs) => {
          currentCache.items.push(...newData);
      },
    }),

This works riiiiight until you need to invalidate the cache. Say you have a page with infinite scroll via pressing a load more button at the bottom, and the user has pressed it 3 times. At this stage, the hook will look like const {data} = useGetLocationsQuery({page: 4});. If page size is 20, data, will contain 80 entries. Then you edit an entry that appears on page 3. Or you add a new location. Both of these operation will invalidate the cache, but the merge strategy provided will simply add the new cache to the end of the previous cache, so const {data} = useGetLocationsQuery({page: 4}); will now have 100 entries, 80 from the original 4 pages and 20 from the 4th page repeated again. Ideally the merge function would have a way of distinguishing cache updates that are due to tag invalidation from cache updates due to parameter changes, but there is currently no way to do this.

Workarounds

There are a number of discussion of how to mitigate this. The solution I went with looks like this.

Firstly, the response payload must include the page number metadata. This is usually the case with paginated endpoints, but this data now needs to be included in the cached result in the query definition.

When merging the cache, only append the new data if the new data page number is greater than the old value:

type PaginatedData<ItemType> = {
  page: number;
  pages: number;
  per_page: number;
  total: number;
  items: ItemType[];
};
...

    getLocations: build.query<PaginatedData<Location>, { page: number }>({
      query: () => ({
        url: "api/v1/locations",
        params: { page }

      }),
      transformResponse: (response: any) => response.data,
      providesTags: (result, error, arg) => [...result.map(location => {type:"Location", id: location.id}), {type:"Location", id: "LIST"}],

      // overwrite cached value when page value changes, treat page
      serializeQueryArgs: ({ queryArgs }) => ({ ...queryArgs, page: undefined }),

      // when overwriting cache value, append new data to old list if page value increases
      merge: (currentCache, newData, otherArgs) => {
        if (newData.page > currentCache.page) {
          currentCache.items.push(...newData.items);
          currentCache = { ...newData, items: currentCache.items };
        } else {
          return newData;
        }
      },
    }),

Then in the component where the hook is called, ensure that the page number is reset to 1 whenever a mutation occurs that will invalidate the useGetLocationsQuery data. Since this page isn't an increase from the previous, the old cache will be discarded. This can be annoying since the component that triggers the mutation and invalidates the data may be completely seperate from the component that queries for the data.

function EditLocationAddress({id}: {id:number}) {
    const [patchLocation, isPatchLoading] = usePatchLocationMutation();

    function onUpdate(locationUpdate:Partial<Location>) {
        patchLocation(locationUpdate);
        // TODO somehow reset the page number to 0 in all relevant places
    }
    ...
    return (
        <div>
            {/* some input that calls onUpdate on change */}
        </div>
    );
}

There is probably a clever way of doing this where the cached page number is used as the canonical page number across all components, and then you could force a reset back to one from any component, but I haven't needed to implement this just yet in any applications.

Maybe something like this? I haven't tried it yet.

function EditLocationAddress({id}: {id:number}) {
    const [patchLocation, isPatchLoading] = usePatchLocationMutation();
    const [getLocationsLazy] = useLazyGetLocationsQuery();

    function onUpdate(locationUpdate:Partial<Location>) {
        patchLocation(locationUpdate);
        getLocationsLazy(
            { page: 1 },
            true // lazy queries ignore cache by default, true overrides this
        );
    }
    ...
    return (
        <div>
            {/* some input that calls onUpdate on change */}
        </div>
    );
}

If you look into the source of a LinkedIn profile page (at your own personal risk) you'll find a text element like this

will have HTML like this

<div class="display-flex flex-row justify-space-between">
    <div class="
          display-flex flex-column full-width">

        <div class="display-flex flex-wrap align-items-center full-height">
            <span class="mr1 t-bold">
                <span aria-hidden="true"><!---->Product manager, Creative coder<!----></span>
                <span class="visually-hidden"><!---->Product manager, Creative coder<!----></span>
            </span>
            <!----><!----><!---->
        </div>
        <span class="t-14 t-normal">
            <span aria-hidden="true"><!---->Freelancer/Consultant<!----></span>
            <span class="visually-hidden"><!---->Freelancer/Consultant<!----></span>
        </span>
        <span class="t-14 t-normal t-black--light">
            <span aria-hidden="true"><!---->2009 - 2018 · 9 yrs<!----></span>
            <span class="visually-hidden"><!---->2009 - 2018 · 9 yrs<!----></span>
        </span>
        <span class="t-14 t-normal t-black--light">
            <span aria-hidden="true"><!---->Europe<!----></span>
            <span class="visually-hidden"><!---->Europe<!----></span>
        </span>

    </div>

    <!---->
    <div class="pvs-entity__action-container">
        <!---->
    </div>
</div>

Gross. Why the hidden duplicated text? Why the empty comments? Why seperate aria versions of text? Is this related to using Ember? LinkedIn has so many little unpleasantries like this.

2024 Update: LinkedIn Still Shit

Still here. Still broken. Still annoying

2025 Update: Slack also does this

When you highlight, copy and paste a name.

The vulnerability was submitted by Jia Tan, a maintainer of XZ project who had been an active contributor since 2021. The vulnerability was extremely obfuscated. Read the original backdoor report by Andres Freund for more details on this.

Maintainers

There are two maintainers of the XZ projects, Jia Tan and Lasse Collin. Lasse Collin is the original author of the XZ Utils library, whereas Jia Tan has only been a maintainer since 2022.

Tan appears so have little to no online footprint prior to 2021 when they started making useful contributions to XZ. It is speculated that Jia Tan is an invented persona.

He has been part of the xz project for 2 years, adding all sorts of binary test files, and to be honest with this level of sophistication I would be suspicious of even older versions of xz until proven otherwise.

Richard Jones

• A Microcosm of the interactions in Open Source projects, and interesting analysis of mailing list discussions about Jia Tan's contributions to the XZ project before Tan was made maintainer
• Lasse Collin's page tracking the vulnerability

Features

• kill switch based on environment variable
  • yolAbejyiejuvnup=Evjtgvsh5okmkAvj is hardcoded (and then obfuscated)
• backdoor itself is secured as it checks for a private key
  • this is an interesting argument against "when you make a backdoor for good guys you also make a backdoor for bad guys" though that's another conversation entirely

Oddities

• In 2022 there were other suspected sock puppet accounts pushing Collin to introduce new maintainers
• Tan disabled a function in oss-fuzzer in 2023 that the exploit relied on that may have revealed the exploit (source)
• the day before the exploit was found the xz-java project added a SECURITY.md file

If you discover a security vulnerability in this project please report it privately. Do not disclose it as a public issue. This gives us time to work with you to fix the issue before public exposure, reducing the chance that the exploit will be used before a patch is released.

• It disabled Linux landlock?
  • This commit introduces a syntax error that prevents Linux landlock from being activated. The test program designed to test if landlock was supported would always fail due to this errant ..
• Tan's first GitHub PR is to libarchive and is suspect as it subtly replaces safe_printf calls with unsafe fprintf

Discovery

I was doing some micro-benchmarking at the time, needed to quiesce the system to reduce noise. Saw sshd processes were using a surprising amount of CPU, despite immediately failing because of wrong usernames etc. Profiled sshd, showing lots of cpu time in liblzma, with perf unable to attribute it to a symbol. Got suspicious. Recalled that I had seen an odd valgrind complaint in automated testing of postgres, a few weeks earlier, after package updates.

Really required a lot of coincidences.

Andres Freund (a Postgres developer at Microsoft)

As noted by nurple on HN, this exploit was found for similar reasons to Ken Thompson's supply chain exploit was detected. Strange performance sparking curiosity.

Links

• FAQ on the exploit by Sam James
• Initial discussion on hn
• CVE-2024-3094 Report
• Original backdoor report by Freund
• Discovery of RCE
• Technologist vs Spy, making the case that based on the behaviour and circumstances surrounding the bug were that of organised actors
• XZ Backdoor Documentation
• XZ Bash-Stage Obfuscation Explained
• Ars Technica Overview
• PoC with substituted public key
• Even more links
• Timeline of XZ
• Jia Tanning Go Code

I have 20GiB+ of photos on my phone and would like a backup. My primary Nextcloud account is synced to my PCs, so any file added to it will be downloaded to all devices. I don't need local access to these photos on all my PCs, so I created a seperate Nextcloud account just for camera roll uploads. If I needed to access these photos from a PC I could log in to the Nextcloud web interface with the camera roll account.

Attempting to use Auto-Upload on my phone's Camera folder was messy. It kept uploading photos to the wrong Nextcloud account, incorrectly counting how many files there were, and did not supporting bidirectional sync. It was unpredictable how long it would take to actually trigger an upload, not having a manual way of starting one. It also limited automatic uploads to a single folder. These issues were all seperate from the fact that the UI was extremely glitchy as it tried to show 20GiB of photos.

I found using FolderSync a much better experience. It let me set up bidirectional sync between custom Nextcloud folders and local folders, let me choose cadence for syncing (with many configuration options like only allowing upload when charging) and allowed me to manually trigger a sync. The premium version is absolutely worth it. I'm only scratching the surface of what it can do here, but for my needs it's perfect.

You click it and you are taken direct to the paper. It really streamlines the process for a lot of sites.

It hilariously appears on Wikipedia articles, as if the University of Western Australia has been incredibly gracious by allowing me to see Wikipedia. The reasoning here is that access to (at least one of) the citations is being provided through LibKey Nomad, but this makes the banner no less obnoxious.

The banner doesn't even have a function like it does on other journals, clicking it just takes you to the references list.

Wikipedia is one of the most impressive things humans have created. Keep your banners to yourself, Third Iron.

Break any of these rules sooner than say anything outright barbarous.

George Orwell

This whole website is a living document, but this page is especially living. These are strong beliefs that are weakly held, I'm certain many of these will change over time.

Some of these will seem trivial and obvious, but they are all written because I have seem them consistently violated in professional settings. These writing were initially intended to be a code practices guide, but they became just angry venting.

This will block until the logs print accept connections twice, or 500 seconds elapses, with an return code to match. Good for blocking a CD pipeline until a certain log has been output.

( docker compose logs postgres -f & ) | timeout 500 grep -m2 "accept connections"

I came across this when using initdb.d with Docker and Postgres. initdb.d will run init scripts when the Postgres container is started, but these are internal to the container, so do not block docker start or docker compose up. Despite this, Postgres cannot be connected to until the init scripts have completed. A quirk of the way the Postgres process in the container runs is that it starts up, loads the script, then restarts. This prints "postgres is ready to accept connections" twice, but only the second time indicates that Postgres is actually ready. This little grep timer was a simple way to block the CD pipeline.

I adapted it from this.

requires = [
    'jmespath>=0.7.1,<2.0.0',
    'python-dateutil>=2.1,<3.0.0',
    # Prior to Python 3.10, Python doesn't require openssl 1.1.1
    # but urllib3 2.0+ does. This means all botocore users will be
    # broken by default on Amazon Linux 2 and AWS Lambda without this pin.
    'urllib3>=1.25.4,<1.27 ; python_version < "3.10"',
    'urllib3>=1.25.4,!=2.2.0,<3 ; python_version >= "3.10"',
]

will not have the Python version shown when running poetry show, despite some the package ranges depending on the Python version of the project. On a Python project where the pyproject.toml specifies Python 3.9, poetry show will only return the urllib3 version range that is valid for Python 3.9.

[~/projects/prosebit] (develop)  
> head pyproject.toml
[tool.poetry]
name = "prosebit"
version = "0.1.0"
description = ""
authors = ["Your Name <you@example.com>"]
readme = "README.md"

[tool.poetry.dependencies]
python = "3.9"

[~/projects/prosebit] (develop)  
> poetry show botocore
 name         : botocore                               
 version      : 1.34.144                               
 description  : Low-level, data-driven core of boto 3. 

dependencies
 - jmespath >=0.7.1,<2.0.0
 - python-dateutil >=2.1,<3.0.0
 - urllib3 >=1.25.4,<1.27

required by
 - boto3 >=1.34.144,<1.35.0
 - s3transfer >=1.33.2,<2.0a.0

On a Python project where the pyproject.toml specifies Python 3.10, poetry show will only return the urllib3 version range that is valid for Python 3.10.

[~/projects/prosebit] (develop)  
> head pyproject.toml
[tool.poetry]
name = "prosebit"
version = "0.1.0"
description = ""
authors = ["Your Name <you@example.com>"]
readme = "README.md"

[tool.poetry.dependencies]
python = "3.10"

[~/projects/prosebit] (develop)  
> poetry show botocore
 name         : botocore                               
 version      : 1.34.144                               
 description  : Low-level, data-driven core of boto 3. 

dependencies
 - jmespath >=0.7.1,<2.0.0
 - python-dateutil >=2.1,<3.0.0
 - urllib3 >=1.25.4,<2.2.0 || >2.2.0,<3

required by
 - boto3 >=1.34.144,<1.35.0
 - s3transfer >=1.33.2,<2.0a.0

On a Python project where a range is specified that covers multiple urllib3 package ranges, poetry show will show both ranges without specifying that the ranges apply to different Python versions.

[~/projects/prosebit] (develop)  
> head pyproject.toml
[tool.poetry]
name = "prosebit"
version = "0.1.0"
description = ""
authors = ["Your Name <you@example.com>"]
readme = "README.md"

[tool.poetry.dependencies]
python = ">=3.9,<3.12"

[~/projects/prosebit] (develop)  
> poetry show botocore
 name         : botocore                               
 version      : 1.34.144                               
 description  : Low-level, data-driven core of boto 3. 

dependencies
 - jmespath >=0.7.1,<2.0.0
 - python-dateutil >=2.1,<3.0.0
 - urllib3 >=1.25.4,<1.27
 - urllib3 >=1.25.4,<2.2.0 || >2.2.0,<3

required by
 - boto3 >=1.34.144,<1.35.0
 - s3transfer >=1.33.2,<2.0a.0

Despite displaying both ranges in poetry show, Poetry will only use the oldest range when running poetry lock or poetry install . This can lead to a disconnect between the package ranges that Poetry is reporting as valid and the package ranges that Poetry will actually attempt to use when running.

I discovered this the hard way when trying to install kinde-python-sdk and boto3 within the same project. boto3 requires botocore which requires urllib3. kinde-python-sdk also requires urllib3. Since my project was set to use python = ">=3.9,<3.12", Poetry was listing both ranges in poetry show, but only using the range urllib3 >=1.25.4,<1.27 when installing botocore. This resulted in headaches because kinde-python-sdk requires urllib3 >=2.2.1,<2.3.0, so it appeared like botocore and kinde-python-sdk could coexist when I ran poetry show, but failed to install every time I tried.

Another important detail to note is that this is all dependent on the Python version specified in pyproject.toml. The Python version you are actually running does not change the behaviour of Poetry. I ran into all of these problems when running Python 3.11, so was confused for hours.

poetry show should report the Python versions that each package dependency range is valid for, since this turned a relatively simple dependency conflict into a multi-hour dependency conflict. I was only able to figure out the exact cause by reading the setup script for botocore.

While it is extremely effective for building software quickly, it is often destructive to other aspects of one's life, such as healthy eating, relationships, and especially sleep.

History

I got mad at a competitor/company/friend with shitty practices/existing tool. Spend multiple days writing code. git push

Spite Driven Development Cycle

1. get mad
2. think you can do it better yourself
3. feel the need to prove you can do better
4. git init
5. design feature with a scope exactly commensurate to your anger
6. forgo loved ones and human interaction
7. finish feature
8. git commit
9. see 5
10. deploy
11. see 5
12. run it 40 times just to watch it work, injecting dopamine directly into your veins
13. rest

Goals

Victory.

Non Goals

Sustenance, testing, clean code.

Development Frameworks

Much like how ruby+rspec is very well suited to test driven development, many frameworks are well suited to SDD. Whichever framework you know is the ideal framework for SDD. Time is of the essence and you have no-one to please but yourself. Spite burns hot but it burns dirty, and it is not a renewable resource. Your must strike while the iron is hot and complete the project before you are sapped of the hatred that started all this.

And after the arguing has concluded, the fighting parties express that they respect the other.

These are rare. But it isn't rare that upon finding one of these I will glance at the usernames.

Today I glanced at the usernames of two people having a beautiful argument on a forum:

"euronforpresident"

And their opponent:

"Hitleresque"

Yea as long as you do all the work and watch all the lectures you’ll be chilling

seph

I did my Computer Science degree from 2020 to 2023, coming out with a BSc. Computer Science, Cybersecurity, minoring in Data Science. I have omitted statistics units because I have nothing intelligible to say about them¹.

Just do Coders For Causes, you will learn more in that than entire semesters of this degree. Learn how to use Git as fast as possible then force all your group project members to use it. Narrow down your problems as much as possible, then google the most generic possible description of it. If you see someone using semicolons mid-sentence regularly it's probably Chris McDonald.

First Year Units

CITS1001 Software Engineering with Java (called Object Oriented Programming when I took it in 2020):

• serves as the introduction to programming for many students
• actively bad introduction to programming
• spends time describing the conceptual model of objects and encapsulation before describing variables and if statements
• class only uses BlueJ (yuck) and as such never teaches you to use a main function. Met students who had completed the class and were still incapable of actually running a Java program
• glad that it is being replaced with CITS2005

CITS1003 Intro to Cybersecurity:

• extremely fun introduction to basic cybersecurity concepts
• main project was a semester long CTF
• perhaps a bit light on content but gives a good taste of the major

CITS1401 Computational Thinking with Python:

• much better intro to programming
• weirdly speedruns 2 years of Computer Science ATAR in the first lesson for no reason
• took 3 weeks to get to if statements in Python which is pretty poor
• decent intro though

CITS1402 Relational Databases

• dead boring but theres no way not to be, it's databases

Second Year Units

CITS2002 Systems Programming

• Chris McDonald is an excellent lecturer
• good introduction to C
• challenging projects but you learn a lot
• very rewarding
• this and CITS2200 have the highest kill rate for comsci degrees ^{[citation needed]}. partially because they are hard, partially because the previous units did a pretty bad job preparing students for them

CITS2003 Open Source Tools & Scripting

• teaches Bash and Unix which are important and only orthogonally explained in CITS2002
• teaches sed and AWK relatively well
• includes Make for some reason, no reason literally cut this its covered in CITS2002 and is actually relevant there
• also includes Git but never actually requires its use so it feels useless even though it is most students first introduction to it. git should be in CITS1401.
• somehow manages to completely screw up the assessments every year
• see Michael Wise

CITS2200 Data Structures & Algorithms

• necessary evil
• teaches important concepts effectively, relatively dry though
• assessments are done in Java and this leads to many stupid problems

CITS2211 Discrete Structures

• the theoretical basis of what a computer actually is
• very interesting but also very hard
• very disconnected from the rest of the degree sadly

CITS2402 Introduction to Data Science

• actual waste of time
• you can learn this entire unit in a day but watching some tutorials on matplotlib, numpy and pandas
• feels like watching a fireship video at 0.005 speed

Third Year Units

CITS3001 Algorithms, Agents & Artificial Intelligence

• so much wasted potential
• could be one of the most interesting units in the whole degree, seems like it was before my time
• tries to cover so much but ends up covering very little effectively
• main project was a disaster in 2022

CITS3002 Computer Networks

• Taught by Oppy himself
• Very interesting content, well taught
• projects get your hands dirty with creating actual protocols and working with sockets
• few things were more satisfying in the entire degree than actually running my final project for this over the internet between me and my partners houses and watching it run
• spiritual sequel to Systems Programming

CITS3003 Graphics and Animation²

• abandoned
• feels like it was really interesting in 2009, but the unit coordinator who cared about it has since left and now it wanders the optional units lists like a zombie
• project hasn't changed majorly in 10 years, though it has gotten more convoluted
• there are certainly past versions of it on github if you are so inclined
• soulless, out of date, and wasted potential as it could be one of the most interesting units

CITS3006 Penetration Testing

• amazing
• final assessment is literally break into this VM, then secure it and swap with other groups
• good balance of pratical and theoretical
• Jin Hong is fantastic
• lab instructors are all great
• had one lecture that wasn't allowed to be recorded because it taught actual live vulnerabilities in UWA systems, excellent, all units should have one of these
• best unit in the whole course

CITS3007 Secure Coding

• the worst C unit by default, only because the others are just so good
• teaches you how to write vulnerable C code, and how to turn off compiler safety checks
• is geniunely interesting
• Arran Stuart is great, seems like the lecturer who is most in touch with modern software engineering?

CITS3401 Data Warehousing

• actual trash
• feels like I learnt 5 things about large scale data storage and nothing else
• project is an arbitrary mess
• pratical side of the unit is a joke
• got really interesting for 2 weeks when it completely switches gears to talk about graph databases but then lets you down again

CITS3403 Agile Web Development

• really fun and very practical
• FIRST ACTUAL USE OF Git (do no wait till third year, learn this in year 1 semester 1) how did it take this long
• well taught
• very fun project

CITS3200 Professional Computing

• your capstone project with an actual client, aka gambling your marks
• if your client is chill you will do well, if not you are ruined
• e.g. my team shipped actual malware and got a HD
• teams are allocated based on having an even WAM spread so get hyped for mark rubber-banding
• there are lectures
• 2/10 lectures will be valuable
• 3/10 will be companies hyping themselves up
• 4/10 will be inane ethics bullshit
• 1/10 will be alleged war criminals
• all prior units have not adequately prepared you for this, go learn django or React because you are very likely going to need to know these. if you are wondering if you should make a web app you should probably just make a web app

Miscellaneous Advice

Labs are the only thing in the degree you can't get from youtube or the Internet. If you are bad, actually do the labs, go in and ask the instructors questions. It's annoying but they can help you bridge the gap between trash and passing.

Learn how to use the command line ASAP. Learn git. Seriously go learn git. So many people I met couldn't use git in their third year. How they made it that far sending code snippets over discord is beyond me. Bully everyone you know into using git. You will actually lose 20% mark if you don't use git+github for a group project because you will waste so much time trying to coordinate the project. If git is hurting your brain try using GitHub Desktop which makes it a bit easier to use for newcomers.

Have other hobbies. Doesn't matter what they are but gaming doesn't count if it's your only hobby.

Go to social events with clubs. The specific club doesn't matter, they are all fine. Alcohol helps, if you are so inclined (science union pub crawls are great). It's very easy in computer science to not make actually make any friends and do everything online. But you will need friends to not be sad and die alone.

If you've made it this far, here's another opinionated essay on university.

snakeware is an experimental Linux-based OS with developed in 2020. Its userspace is written entirely in Python, barring a single Busybox root process. It was created by Joshua Moore drawing inspiration from the Commodore 64. The window manager, snakewm, is written primarily with pygame_gui. It is not based on X11 or Wayland, instead writing directly to the framebuffer (/dev/fb0).

On first boot, snakeware launches you directly a the Python interpreter. From here you can run Python commands directly, launch the window manager, or launch CLI games.

To launch snakewm from the interpreter, run the snakewm command. From snakewm the aopp menu can be opened using the Super key. From here a number of applications can be launched.

To launch CLI games, enter the following commands:

>>> import snake_games
>>> snake_games.menu()

Games included as of 2022 are snake, snakepaint, and circlez.

History

snakeware was a short-lived project and should be considered inactive, with most significant contributions ending in 2020. It was created and maintained by Joshua Moore and had a small number of contributors. Some of the applications included in snakeware never reached their intended goals, such as the included terminal emulator snaketerm which is extremely rudimentary.

One of the goals in making the entire userspace in Python was to make it modifiable by the user with little effort. As Python is interpreted, all code for the window manager and the interface would be visible and modifiable by any snakeware user, and would be easy to extend. Unfortunately, the planned text editor for snakeware, CATH, was never finished.

Other planned projects were networking, a chat application, and a package system built on top of PyPI called snakeoil.

The project was coordinated over a Discord server, though this hasn't been active for some time.

Links

• snakeware source code
• CATH text editor

I haven't written on here in a while, but I have been writing on my public notes. At this point I've got over 300 pages on there, far more than I ever wrote on here but in a format that looks a lot more like a wiki. This is mostly a factor of convenience, the format of the notes means I can iteratively add whatever I am thinking about, without the expectation of the writing being complete and canonical. The writing is organised into a hierarchy of folders, with tags and backlinks. I find this format much better for wiki-style writing but doesn't lend itself well to chronological feeds like this one.

Occasionally I would write a note on there that would fit well into the blog format, or was long and more story based. Some of my posts on this blog worked much better as wiki pages than as blog posts. I have wanted to unify these two sites for a long time now. Last week I finally got around to it!

The Ochrs site generator that I wrote to build the wiki can now generate chronological feeds of posts and RSS feeds. Feeds are generated based on tags, where each tag has its own RSS feed. A note can be added to a chronological feed by adding a publish date (date field in the frontmatter), which will then be used as the publish date in all feeds that the note is a part of. This approach is great since it allows each note to exist anywhere in the wiki hierarchy while also being a part of many feeds. The RSS feed will be at notes.zachmanson.com/<tagname>.xml, and the list of notes in a chronological feed can be shown on a page using the ochrs:chrono:<tagname> build function (see Ochrs Syntax for more on how this works), which will results in all the posts being displayed in blog-style HTML.

To succeed zachmanson.com/blog/ I have created the posts tag. The feeds can be seen at notes.zachmanson.com/posts and using RSS. I have moved the existing posts here over to the this new feed.

If you are reading this using RSS then I would like to apologise that you will have to subscribe to a new feed. I would have liked to automatically redirect your feed reader, but GitHub Pages doesn't let you create 301 redirects. The redirect-from plugin is capable of meta tag redirects, but those are soft and not followed by feed readers. This is very frustrating.

I've marked a bunch of longer notes I've made as posts, so the new feed already has 7 new posts. Hopefully more will come soon!

• its - possessive
• it's - contraction of it is

If I were in school and mixed up these two I would be admonished. There's a part of my brain I will never be able to exorcise the belief that confusing these two spellings is a sign of poor grammar. But equally, my brain never liked the apostrophe-less its for possession. The word seemed naked to me.

It(')s sits at the crossroads of the two main uses of the apostrophe in English, contraction and possession.

The possessive form of it(')s has an interesting quirk in that it sits at the crossroads of another inconsistency - do possessive pronouns get apostrophes? If you think of it as a pronoun akin to his, hers, and theirs (sometimes called "definite" pronouns) then the apostrophe-less its seems fine. If you think of it as similar to other neutral pronoun possessive like one's or somebody's ("indefinite" pronouns, then the absent apostrophe seems inconsistent. The concept of definite pronouns was never pointed out to me in school, primary school me intuited that its should be treated the same as my name but I was told that it was just an edge case I would have remember forever

My childhood assumption is more reasonable than my teachers would have told me. Like many grammar rules, the rules around it(')s have changed over time. Etymonline claims possessive it(')s dates back to the 1500s and was originally spelt it's, only in the 1800s did the apostrophe fall out of use. It seems like the 1800s change occurred to make room for contracted it's because the other contraction for it is, 'tis, fell out of fashion.

Given the attitude my teacher had when teaching this "rule", I find the youth of this "rule" very satisfying. The unconvincing arguments they gave supporting it are not set in stone.

The part that is most stupid about this whole situation to me is that the apostrophe does very little to actually make things clearer. It is extremely hard to construct sentence where the meaning of it(')s cannot easily be gleaned from context, and most sentences where either form is valid in the same place sound awkward.

The closest example I have found to a sentence where the apostrophe adds semantic clarity is this:

The company announced it(')s plans for expansion.

If it(')s is possessive, then semantically it means "the company has announced the plans it has for expansion".

If it(')s is a contraction, then semantically the sentence means "the company has announced it has plans for expansion".

These are different, but I find the second form very awkward.

Useless Dropdowns

This dropdown should list the environments instead of revealing a button to take you to a page that lists the environments. This is an unnecessary second click.

This also means you are unable to switch environment without losing the page you are on.

Unclickable Icons

For some reason the left facing chevron is not clickable, only the word "Home" is.

Bizarre Breadcrumbs

When you go to the "Users Profile" screen, the top left back icon doesn't take you back to the "Users" screen, but remains a "Home" button.

The only way to navigate back is the the small grey "User" text above the user's name.

This is something that almost all basic websites can get right. Breadcrumb navigation or consistent back behaviour would be vastly preferable here.

There is little consistency between parts of the interface that are clickable and those that are not. This makes navigating quite difficult.

"Full-stack" now includes a lot more pancakes. We've added layers and layers of abstractions, tools, and professionalism into every stage of "hosting a site." This is in part due to real factors related to adding hundreds of millions of people to the internet, giving them always-on supercomputers they check at several dozen times a day, common infrastructure and cloud platforms providing solutions for minutiae that used to gate out amateur players, and the explosion of VC/zero-interest capital in the last decade meaning a ton of companies were playing the "eat the world or die" game.

Pablo Meier

Web development is an exercise in distributed execution of program, where some parts of your program execute in a (mostly) trusted environment on the server and some execute on a untrusted environment on the client. Almost all problems in web development can be derived from this breakdown, and the limitations of each of these environments.

1. How can these two environments communicate efficiently, securely, and effectively
2. Which processing is better handled on the server and which is better handled on the client
3. Half of your program runs in an untrusted environment
4. Half of your program has a limited set of system resources that are shared between all users, performance of the server can impact all users simultaneously

None of this has even gotten to JavaScript and CSS, each of which are their own rabbit-holes.

Problems that arise from this:

• You have a machine in your house you want to serve HTML files to people on the internet (Apache, Nginx)
  • They don't look pretty (CSS)
    • Your CSS looks bad on small screens! (responsive design, flexbox)
  • There's no way to make them change without manually changing the HTML (server rendering, initially with Perl, PHP)
    • You want your users to be able to send information to you (HTML Forms and later APIs)
      • You want certain users to see different things (Authentication and Authorization)
    • You want to store data used to render your site, and store data about your users (databases, MySQL, Postgres)
      • You need to ensure that your users can't sneak database queries into their data (SQL sanitisation)
      • Your programming language of choice doesn't match the model that SQL databases use (ORMs)
      • Your database is too slow! Your schema wasn't designed for efficient queries with so many users. You need to redesign the database and migrate the data to the new schema (database schema migrations and revision management)
      • Still too many people are trying to read and write to your database at once (Redis, write-through caching)
      • Your database is getting too slow! You need to start scaling (Vertical scaling, data migration)
      • Even on the biggest server you can afford you database is still too slow! (sharding, horizontal scaling)
  • There's no way to make that page move (JavaScript)
    • The page is programmable but there's no way to make that page request more data (XMLHttpRequest)
      • Sending XML kinda sucks (JSON)
      • Now that you can send between your site and your server using APIs! But you need to ensure that the requests and responses actually contain the data you expect them to (Request and Response validation, JSON de/serialisation)
      • You only want your own website to be able to send your server requests (CORS)
        • You want other websites to send your server requests (CORS)
    • JavaScript is really annoying and varies between browsers (JQuery)
      • some new JavaScript features are really nice but old browsers don't support them (polyfills, Babel, Lebab)
    • Even with JQuery, complex applications become pretty hard to manage (JavaScript libraries for complex web applications, AngularJS, React, many many more)
      • These libraries are so nice we want to use them for everything instead of gross HTML (JS managed routing, React Router, single page applications)
      • Interface design with CSS kinda sucks for especially for complex applications (SASS, Tailwind, prebuilt UI component libraries, Styled Components)
      • Complex applications need complex application state models (Redux, Zustand, NGXS)
      • Complex applications need sane data fetching patterns and caching (React Query, SWR, RTK Query)
        • It's annoying to have to build bespoke APIs for every different combination of data that your frontend wants, wouldn't it be nice if the frontend could just tell us what it wanted and the backend figured it out (GraphQL)
      • Even with caching and internal state and JS routing, single applications are pretty slow to actually show useful information since they take multiple requests roundtrips to build the UI and then load the data
        • Server rendered frontend frameworks, where the frontend code for a page is run on the server before sending it to the client so that the initial data is already present on first load, then normal SPA behaviour can take over after that (made possible because of Node.js, Next.js, Remix)
          • Your server now needs to run JavaScript, which is probably only possible using Node.js
          • This is great for basic applications but starts to get awkward when you have complex data structures and component structures as you need to know all data requirements at a route level rather than a component level
            • Server components allow server side rendering on a component level, by running some of the rendering code on the backend, populating it with data, and slotting that wholesale into a SPA (React Server Components)
    • This language you've been using JavaScript has constant type errors, if only you could specify types (TypeScript, Flow)
    • Both JavaScript and TypeScript are bad at actually representing HTML (JSX)
  • Your marketing team wants a website they can control without writing code (CMS, Wordpress, many more)
    • They want it on the same domain name (server routing configuration, e.g. Nginx conf)
  • Your backend server machine's operating system needs to be configured for security (Linux system administration)
    • Uh oh! CVE in one of the libraries your server uses! You need a way to update your dependencies (package managers)
    • Your server state is getting a bit complicated, you aren't sure if you could recreate it now if you wanted to. You also have trouble matching it on your development device. (Docker)
    • Your backend server is being crushed by your immense popularity, (bigger server, vertical scaling)
    • You bought the biggest server you can afford and its still too much traffic! (horizontal scaling)
      • How do you distribute load across your multiple servers (load balancing)
      • Sometimes your load is so high that you need to add more servers to your fleet of servers, but it's annoying to do it manually (Kubernetes)
  • Managing your own servers is getting time consuming, if only there was a way to have code handle the provisioning of servers (Terraform)

Links

• JavaScript Gom Jabbar
• The Web's Grain
• Frontend
  • The single most impor­tant factor that dif­fer­enti­ates front-end frame­works
• Everyone Has JavaScript, Right?
• My love letter to front-end web development
• Handling Cookies is a Minefield
• Creating PWAs
• Why is everything so scalable?
• Shipping a button in 2026...

This is horrific. I knew this kind of bullshit would happen eventually, but I didn't expect it so soon.

Here is how platforms die: first, they are good to their users; then they abuse their users to make things better for their business customers; finally, they abuse those business customers to claw back all the value for themselves. Then, they die.

Cory Doctorow

The stats page in particular was poorly done. Originally I had made the schema as simple as possible and only stored the record of each game in one big table. This worked for small player counts, but meant calculating rankings was quadratic so the stats page eventually 10+ seconds to load. I only discovered this was happening when the database for Penultimate Guitar would be killed to allocate more resources every time someone loaded the stats page.

Since rewriting the database meant I'd need to get rid of the entire backend, I decided this was the time to move away from Flask and static JavaScript and port it to Next.js. I had been meaning to do this for a while. The Vanilla JS I had been using prior was very janky and poorly made. I was still unemployed at this time and had plenty of free time since most of my friends had left Melbourne to see their families for Christmas.

The new version of Minecraftle is deployed now on Vercel with a proper instance of Postgres for storing user scores. Rankings are still slow to calculate since all million+ players must be ordered, but they are calculated once per hour via a cronjob that refreshes a materialised view so the pageload is fast. I'm sure I could do something clever here, chunking the calculations or having them incrementally calculated when a new game score is submitted, but this works for now.

Alongside this rewrite I was able to add a few long requested features, like a clear button.

Mistakes

Database Broke

I accidentally ran the migration script twice, once a few weeks prior to deployment to generate some test data and once on the day I deployed. I forgot about the initial run in the intervening weeks. Making matters worse, the second run used the old dump of the database, meaning that all scores were double what they were 3 weeks prior. This was painful to diagnose as some scores had gone up while others had gone down. I was eventually able to figure out what had happened thanks to this bug report which contained a screenshot of the scores the day before. Thank you very much suppergerrie2!

CDN vs Audio Files

Back when Minecraftle was just a uni project, one of my teammates, Harrison Oates, added a button that would play in game audio from Minecraft. This was cute and insignificant, to the point where I forgot it existed. When I deployed on Vercel this became a problem since almost all my bandwidth (100GiB) was used by this single mp3 file! I removed this feature, but other static assets were going to use my remaining bandwidth. I had to switch to running it on a new DigitalOcean droplet for the rest of the month.

Hopefully this are the last updates Minecraftle will need for a long time!

I miss having more friends than I can handle. In Perth I would often whine about how I longed for time on my own, but I rarely experience that here. I have far more time on my own now so I guess that desire is satiated. Here I have my WA-expat friends and the people they have introduced me to. A few of those have graduated into actual friends, it's a work in progress.

I'm very grateful that the expats have looked after me, I'd have been lost without them. They've been carrying me so hard. Despite that, when they are busy or I fear I'm smothering them, I have nobody to see. That's something I haven't felt in many years, if ever.

When I have an idea for a project that excites me I often think of nothing else. I'll stay up till dawn working on the project, not letting myself rest until the feature is done or the bug is fixed. This is complemented by by a desire to always be progressing in one way or another. This manifests as a constant tug of wanting to learn something, progress a skill. It was the feeling that drove me to start learning piano (though everything I learnt must be atrophied now).

When in the grips of this, anything unimportant feels like a waste of time. For example, video games lose their appeal immediately.

This is all preamble to the point: the normal drive I have to build something or create something is still there but my brain has made "making new friends" the primary goal. Any time free time I'm not spending on this makes me feel wasteful. This is often.

When I can't be progressing socially I'm trying to fill my time with other ancillary goals, improving at sketching, cooking, exploring Melbourne. This helps, but it doesn't quite scratch the itch.

Usability

537c928: Made the emoji summary more vague, so a correct guess shows up as 9 green squares no matter what, rather than giving away the shape of the final solution.

Minecraftle 24/05/2022

⬜⬜⬜
⬜⬜⬜
⬜⬜⬜

🟩🟩🟨
⬜🟩⬜
⬜🟩⬜

🟩🟩⬜
🟩🟩⬜
⬜🟩⬜

Minecraftle 25/05/2022 3/10
⬜🟩⬜
⬜⬜⬜
⬜⬜⬜

⬜⬜⬜
🟩🟩⬜
🟨⬜⬜

🟩🟩🟩
🟩🟩🟩
🟩🟩🟩

23dc225: Added check so that only valid Minecraft recipes could be submitted as guesses.

bc40b98: Added proper support for horizontal reflections of recipes.

f3295d7 & 36386df: Made end-of-game popup display different text for Random games.

fef189d: Changed the given items for a more interesting set of possible recipes.

30a3829: Made end-of-game popup togglable.

f43b062: Added loading indicator to initial pageload.

8a842d9: Added slot highlighting to the ingredients panel to help keep track of which items have been used before.

Optimisation

c502eb2: Rewrote the entire script that turned the 600+ Minecraft crafting recipe JSON files into single file with a usable schema. Previous implementation was very messy, future modifications will be much easier.

172b3f2: Optimised recipes validation, still relatively inefficient though.

cd0c61e: Made game submission API a seperate endpoint to user stats endpoint, rather than being a hacky overload of the stats endpoint.

007865b: Significantly reduced size of recipes.json to only include recipes that are actually possible to create with the given ingredients. This reduces initial pageload time and reduces load on my server.

007865b: Set init.js to store recipes.json and items.json in local storage, and only request them if they don't exist there. This makes pageloading much faster, and reduces load on my server.

Revenge

Since initial release 2500+ people have played the game. From what I can tell this primary originated from popularity at a local primary school and the now-defunct LikeWordle.com. Most of these players haven't become regular users though, only playing one or two games. Really its just me and my ex competing for the number one spot on the leaderboard. After months of hard work she overtook me as number 1 and I have been clawing my way back ever since. Obviously I could cheat since I'm the admin but where's the fun in that? Despite that, I'm not opposed to adding features to help me take back the crown.

309a557: Added indicators to the stats page to show users how far behind and ahead they are of their neighbours on the leaderboard.

5dca9d2: Added an account recovery button since I accidentally deleted my account the day after taking back the crown (I swear). This does expose a prexisting security flaw, but does enable it to be used in a positive way. For reference, clearing your browser data will make your device forget which account is it associated with.

Bugfixes

23dc225: Fixed bug caused by the use of item tags in Minecraft source files. Item tags represent groups of items that are effectively interchangable in crafting recipes, such as coal and charcoal. Minecraftle conversion scripts have been updated to expect this, and will replace these with the preferred variant e.g. coal/charcoal group will be replaced with coal.

d98e83a: Forced game to be set to Perth timezone. Deployment VPS is in North America, so the server-side calculation of the current recipes wasn't changing at midnight in Perth, where most of the player base is.

c0ce8c2: Fixed stick recipe being overwritten by second stick recipes that uses bamboo.

It was some of the first JavaScript I ever wrote and it reflects that, much of the old code makes me want to cringe. With the benefit of 6 months professionally working on large TypeScript projects, Minecraftle seems quaint (and somewhat shocking that it even works).

Regardless, it holds a place in my heart as my first web development project with any complexity and is likely responsible for getting my foot in the door at my current job. For this reason I am willing to continue tending the garden it occupies.