novov blog

Review: Portal: Revolution

2026-02-11T00:00:00+12:00

This picture certainly looks very pretty, and is a nice refresher from the environs of Portal 2. From a narrative perspective, it has some flaws though: the idea of Aperture Science's laboratories being exposed to the elements in such a blatant way seems a bit implausible.

Unlike many games, the archetypal mod for a Valve game is a full-fledged separate campaign, which is often listed on its own on Steam. Famously, popular Valve titles such as Team Fortress and Counter-Strike were initially conceived as mods for Half-Life. Throughout the late 1990s and 2000s, there was a boom of mods for Valve's games, but due to the higher barrier to entry presented by modern game development,¹ and a diminishing amount of support provided by Valve, this trend had largely abated by the release of Portal 2.

Nevertheless, a few major² mods were still released, which I will now go through in a blatant attempt to expound about something I am interested in even though it does not directly fall under the ostensible purpose of the post. To be fair, I will be comparing these (well, mainly Mel) to Portal: Revolution a number of times, so it still serves a purpose.

Thinking With Time Machine was the first and probably the worst Portal 2 mod. It has an interesting "time travel" mechanic, based around recording one's past actions and replaying them using an iPad-esque device. Its execution is widely considered mediocre though. The hallmark mechanic quickly becomes confusing, the story has a hokey setup that doesn't deserve a mention, and while it sports an interesting futuristic aesthetic (well, more futuristic than Portal already is) it for some reason decides to abandon the series convention of using white to indicate a portalable surface, with disastrous results for gameplay intelligibility.
Aperture Tag had a really interesting idea, namely, replacing the famous portal gun with a gun that shoots the orange and blue gels introduced in Portal 2. Controversially, it was not made available for free, as is considered customary for a Portal mod. While the titular mechanic is fun and the gameplay decent enough, the graphics and level design lacks a certain polish,³ and the story is nothing to write home about either.
3
Probably a bit more annoying for a Portal 2 lore aficionado like me, who considers the lack of an adequate transition between Old and New Aperture to be an important omission.
Portal Stories: Mel quickly assumed a role as the archetypal Portal 2 mod after its release, one that in my opinion is well-deserved. Mel fans have created fanart and even actual portal guns, which I can't ever see happening for TWTM. It has a level of polish and execution not seen in its forebears, with many new fancy graphical assets and visually stunning and extremely polished environments. Apart from its set-piece moments, visually many of its levels are equivalent quality-wise to those in Portal 2, only with a greater abundance of graphical props and more advanced lighting effects.⁴ Although its soundtrack is by the same composer as Tag's, it is more compelling.

The Achilles heel of Mel is its infamously hard puzzle design: the community members that made it were experienced in solving test chambers, and failed to adequately create a difficulty curve. Although I find them fun, I don't consider them well-balanced; it doesn't help that much of the difficulty is based on cheap cube-swapping conundrums. To the team's credit, they later added easier versions, but when playing through these it is very easy to notice that they are post-facto revisions.

Unlike its precedents, the story has all the finesse one would expect of a professional game, even if the writing isn't quite Valve-level. Virgil is an adequate companion with good voice acting, but he lacks the humour or unique personality of GLaDOS or Wheatley. Conversely, AEGIS is a unique antagonist that compellingly introduces a more mechanical and less "quirky funny robot" character into the Portal universe.
4
To put it another way, if this were Portal 3 this would be percieved as an insipid retread, but in this case it is a testament to the team's skill.
Portal Reloaded is another take on the concept of time travel, to more interesting effect than TWTM. Instead of recording one's actions, one uses a third portal to swap between a version of the test chamber in the past and one in the future. At first, the mechanic is a bit unintuitive, but once you adjust, it creates some entertainingly mind-bending puzzles. While they perhaps are not much easier than Mel they feel a lot fairer and more memorable.

While Reloaded's visuals aren't up to the standard of Mel, they get the job done. Overall it is a bit of a smaller scale mod, which intentionally doesn't have many story elements beyond the test chambers. Its limited scope means it feels almost like a level pack in mod form, but ironically its core mechanic probably possesses the most potential for a Portal 3 if Valve somehow hypothetically finds a way to make the learning curve easier.

After a lengthy development period, Portal: Revolution joined these mods at the start of 2024. It was created by Austrian Stefan Heinz and a small team of developers, who laboured away at it for a number of years. Unsurprisingly, some fans have hyped it up, comparing it to a potential Portal 3, and it does indeed possess polish on the level of Mel. With these grand claims in mind, I took it upon myself to play it... when it released, and then write an article about it a few years later for some reason.

The environment design and additional graphical effects work in tandem to produce great results.

Visually, Revolution is stunning. It introduces higher resolution textures, which are by-and-large suitable replacements for the originals. Large portions of the environment are exposed to the outside world in a way Portal 2 is not, utilising cascaded shadow maps for realistic outdoors illumination. Foliage is now slightly reflective, and volumetric lighting is used in select places to create convincing rays of light. Some assets are replaced with higher-resolution replicas, which are by and large suitable replacements. A number of other subtle improvements are made, aided by an upgrade from DirectX 9 to 11 and OpenGL to Vulkan.

This is not just the result of improved technology, but also impeccable map design, with stunning vistas, overgrown ruins teeming with a wide variety of fauna, and the technological labyrinths one expects from Aperture Science. Unlike Mel, it does introduce a few new visual themes: an "under construction" transitory style between Old and New Apertures, and proper test chambers in behind-the-scenes areas.⁵ While these help keep things fresh and add to the feeling that you've doing something new and cool and interesting within Aperture (in a way Mel's charming-but-rather-unsurprising environments sometimes don't) they've not a total shift like Old Aperture in Portal 2. One of the high points is the Spire, whose sterile nature thematically fits as a contrast to the dilapidated landscape around it. Throughout the game, the outdoors chambers progress from daylight, then sunset, and finally the nighttime, which is executed nicely to create an effect of progression.

Unlike Mel, which boasts a wide array of set pieces, including the spiderlike AEGIS, an underground train introduction, and a panoply of explosions, Revolution is more restrained. Cores often lurk behind panels, with their animatics being minimal when they appear, and the amount of custom models is on the lower side. It basically attempts to have the minimum amount of set pieces one can while still feeling like a full-fledged campaign and not a Reloaded-esque affair. This is an admitted decision to save developer time: Revolution was pushed out on a very strict deadline. To their credit, it is an often successful one, at times being unnoticeable, and during the latter portions of the game it fits nicely with the game's themes. Still, it can occasionally rob the world of a certain joie de vivre and soul.

Portal Revolution's story is probably its weakest link, but can be still compelling and interesting. The dialogue is decent enough and largely carries the mod forwards, with some funny moments, even if it doesn't come close to reaching Portal 2 (not that such a thing would realistically be achievable for a small team), and the premise is a bit generic at first and takes a while to come into its own. This ends up being a disappointment compared to its more unique forbears: in Mel, the protagonist begins in the 50s, and is shunted into the future after a scientific fuckup, but in Revolution, they just wake up and do some tests.

In general, portions of the early game can come off as a bit uninspired at times; just like in Portal 2, there are surprise test chambers where you are flung into the behind-the-scenes areas, and jokes are often retreads of Valve's material. Some find the introductory core character, Stirling, to be grating at first, and I can see why, but there is more to the writing than him; as the game progresses, some interesting concepts and unique thematic elements are explored. Ultimately though, the story is still very much a flawed product; to explain its pros and cons in more depth, I'll have to do some comparison with Portal 2 and Mel, and unfortunately delve into lots of spoilers.

Lengthy expounding about Portal: Revolution's plot, including many spoilers

Around 25 percent of the way through the game, the player just randomly falls down a lift. In the developer commentary, this is explained as a way to communicate the difficulty of the journey and break things up, but in game it feels insufficiently justified. The same feeling permeates the game's first half. At its worst, in Revolution-land, stuff just kinda happens because the writer dictates it.

Although the player has the stated goal of reaching the Spire (with a very beautiful visual setpiece), the actual journey there sometimes feels a bit like a tour through (admittedly very pretty) environments and (admittedly very fun) puzzles with the ultimate objective being a very thin pretext. In Portal 1, the clean manicured chambers slowly become more disturbing as you realise what is going on. In Portal 2, the chambers start off dilapidated with Aperture abandoned for eons, but then GLaDOS fixes them and Wheatley smashes them together. To a lesser degree, Mel suffers from the same flaw, but even there you try to go through the shrubbery to avoid AEGIS, and the goo is rising beneath you all the time, adding pressure and momentum to the narrative. In Revolution, it can sometimes feel like the locations are arbitrary and not influenced by player action or the wider plot.

This lack of depth also extends to the characterisation. Stirling is charming at times, but he doesn't have the same magnetism or connection to the world around him as his cohorts. His dialogue sells the fact that he sees Aperture as a workspace quite well, but we often don't get a sense of him being a cleaning robot; there's space to incorporate this idea into the dialogue more without being excessive. Fortunately, in the second half of the game, things start to show promise of becoming more meaningful. The player reaches the Spire, which has a unique environment and adds interesting elements to Aperture's lore. Then they unfold into an abandoned expanse, which feels more desolate than any in Portal 2. Exploring these ruins leads to Conly, who has a great personality and superb voice acting by Sarah Jacklin.⁶ As the player ferries Conly back up to the Enrichment Centre's upper reaches, one gets enveloped in dread and loss, as there is a neat tonal shift to darker and more depressing environs.⁷

But this quality progression is abruptly broken by Stirling's heel turn, which is not really sufficiently explained or justified. It may make sense in line with his ultimate motivations, but the game doesn't really sell that fact, and it really forgets to make him into much of a compelling villain at all. Going back to the point I made outside this big spoiler disclosure thingamajig, it also feels like he isn't sufficiently distinct from Wheatley in Portal 2. The funniest villain line he has, where the player character is standing on a precipice and he suggests various ways of getting rid of her... well, Wheatley does the same thing in Portal 2, though the creativity of the new scenarios keeps things entertaining at least. The least funny line he has, where he makes a kinda problematic jab about brain damage, is also a retread of Portal 2, but that game is at least capable of getting away with it due to vastly superior writing.⁸ Even his plot arc, where he is your eager helper and guide, then loses you in an dilapidated and revelation-laden underground area, betrays you at the ninth hour when you re-emerge, and finally is very insecure towards both you and his superior... is pretty much the same as Portal 2. Though Heinz claims the last one was unintentional, and I don't think he's lying, a lack of intentionality doesn't make the player not feel like they've done it all before. It is really a testament to other aspects of the mod that these flaws don't totally ruin the whole enchilada.

The most controversial part of Revolution is the ending. Personally, I'm in the boat that doesn't hate the concept. The actual execution, however, leaves something to be desired. Firstly, in part due to the aforementioned deadlines that Heinz and his team set for themselves, it is very sudden; one is punted out of the final test chamber into the boss fight with barely any buildup. By contrast, Portal 2 has you trying to run away from Wheatley while he cack-handedly attempts to kill you to often amusing effect, and in Mel you run around under AEGIS's nose disabling all its security measures.

The other issue is how the ending is contextualised as part of the narrative arc as a whole. Whilst I'm not a stickler for everyone-hugs-each-other-and-the-universe-is-saved affairs, the way this particular ending is implemented means that it doesn't feel like a rewarding conclusion. To pull off an ambivalent-to-bad ending without it feeling like a slap in the face, the story needs to lead up to in a natural way to prevent it feeling jarring; while some of the more depressing vibes during Conly's ascent do pull things in the right emotional direction, they are ultimately insufficient. While I appreciate Stefan's goal of trying something tonally different, I can't really say he succeeds at it.

Conversely, Revolution's puzzles are probably the strongest part of the game. Extant mechanics, such as hard light bridges, cubes, and tractor beams, used in ingenious ways. Unlike Mel, the puzzles also form a coherent difficulty curve, where introductory chambers introduce or re-acquaint players with a mechanic, and then later expand upon things and combine them for more difficult results. If anything, they are too easy, but apart from a few outliers, solving them rarely feels unsatisfying.

The most interesting puzzles in the mod involve the new mechanics, which are creative and entertaining. After playing Portal 2 I struggled to see what additions Valve could make in a future entry, but these could be used to great effect. There are tubes that suck objects from one portion of a test chamber to another, power switches that can enable and disable both hindrances and helpful elements, and paired cubes that act as laser portals, with one end of a laser entering one cube and issuing from the other. They bring diverse possibilities, and appropriately the chambers use them in a variety of ways. But they are ultimately are somewhat under-utilised: for instance, and I am far from the only person to make this critique, the cubes only make a short appearance in the last ten or so chambers.⁹

Compared to Mel, Reloaded, and Portal 2, Revolution's music is sparser, sharing some similarity with the sounds of the first Portal game. Quite often, diegetic sound effects take the centre stage instead of the instruments, and tracks often feel like they've just composed of one synth and not much else. It's a nice touch, and there are some neat moments where a swell of music seamlessly phases in at just the right time. Unlike Mel and like Portal 2, many of these tracks within test chambers are dynamic as well: when you kill a turret or make a fling, the music reacts to you progressing in the test. These two changes mean that compared to Mel, the aural environment of the mod feels more reactive and less constant. Mel's music is nice to listen to outside of the game, but can feel a bit repetitive in test chambers; I have no such qualms with Revolution.

However, sometimes this music is too sparse. The tracks' simplicity comes off as fine-tuned minimalism in many places, but a few are left wanting for more aural complexity. Especially outside of tests, the game can stretch into overlong periods of silence, with some areas lacking any music at all (again, this is a consequence of the mod's expeditious release). While not every moment needs music, a few areas such as entering the Spire or just after the Spire fails and you are teleported to Old Aperture felt they deserved more musical acknowledgement than they got.

I feel like equating Revolution to Portal 3 is doing it a disservice. Unlike some people,¹⁰ I like many things about the mod, but I acknowledge that it has flaws as well. Ultimately, comparing it to a new title puts it on a pedestal, creating a vision of a Valve-like holistic product which perfectly solves fans' Portal fix, creating unrealistic expectations that can't be met, and sandpapering over the actual development process.

3.9 out of 5 Novov Affirmation Points

1
Even though Valve's Hammer editor (with a lineage stretching all the way back to Quake) is still based around the "old way" of doing things in many respects, the additional graphical detail still makes development harder.
2
"Major" being defined as receiving some news coverage by gaming sites and being listed on Steam as a standalone title, at the time of Revolution's release.
3
Probably a bit more annoying for a Portal 2 lore aficionado like me, who considers the lack of an adequate transition between Old and New Aperture to be an important omission.
4
To put it another way, if this were Portal 3 this would be percieved as an insipid retread, but in this case it is a testament to the team's skill.
5
Although these are visually attractive, the actual convincingness from a lore perspective is questionable at times. I'll excuse it though.
6
Why she hasn't got heaps of roles is beyond me. Though perhaps I'm just biased towards my Antipodean cohorts.
7
Though the interspersion of test chambers and behind-the-scenes sections seems rather contrived at times.
8
~~I've had a concussion once, I can give GLaDOS a pass.~~
9
To be fair, a similar critique could be made about the gels in Portal 2, though to a lesser extent.
10
Also... a bit of a rant, but Revolution does take into account the Borealis, sorry. Like if you are going to complain about the game not taking into Portal lore, at least get your details right... still a very interesting video overall, even if I absolutely disagree about Revolution or about Mel's excessive cube-swapping being a good thing.

Behind Homepage

2024-12-20T00:00:00+12:00

I'm the developer of the Homepage plugin for the Obsidian notetaking app. One of the most popular plugins within the community repository, it adds the ability to designate certain notes, workspaces, canvases, etc. to open on startup or otherwise perform actions when opening a vault.

This may appear to be a simple and painless affair, but there's a surprising amount of complexity involved. For experienced developers, much of this will not come as a surprise, but for those who are learning the ropes of plugin development, or are otherwise interested, I hope this is somewhat informative.

Origins

I initially started using Obsidian as a replacement to my TiddlyWiki file. While TiddlyWiki is great in many respects, its single-file structure is hard to use in certain circumstances and not very portable. To work around this, I used the official TiddlyDesktop app, but it launches on a wiki chooser every time, making quick notetaking rather difficult. As I continued using my wiki, I found myself gravitating towards plain text files for quick notes unrelated to bigger interlinked documents. With Obsidian, these could be transformed to Markdown with just a few quick edits, and co-exist with the rest of my notes. And if I was the midst of coding in my text editor, I could still start a note in the same app and then add it to my Obsidian vault when done.

However, there was one dealbreaker with Obsidian. TiddlyWiki can start on a designated 'tiddler';¹ I had made a custom-built 'Home' tiddler with a set of quick links, and this became a core part of my workflow.² But Obsidian has no inbuilt mechanism for this, meaning that I had to wade through whatever I was last doing every time I opened it. Fortunately, Obsidian had an then-incipient plugin system. Since I already knew how to program, it was very easy to start a new plugin using the official template. Although it took me a while to get up to speed with the API (and figure how to avoid loading the homepage when the plugin is installed), the first version ended up being very simple:

export default class Homepage extends Plugin {
    settings: HomepageSettings;

    async onload() {
        await this.loadSettings();
        this.addSettingTab(new HomepageSettingTab(this.app, this));

        this.addCommand({
            id: "open-homepage",
            name: "Open Homepage",
            callback: this.openHomepage,
        });

        if(this.app.workspace.activeLeaf == null) {
            //only do on startup, not plugin activation
            this.app.workspace.onLayoutReady(this.openHomepage);
        }
    }

    //continued...

It was rudimentary and its logic was really simple. It went something like this:

Clear all existing notes
Open the specified homepage note

It was the proverbial Model T of plugins - the only option was to change what note was the homepage. After it flew past the submission process, I expected that it would get around 3 users. After all, there were already quite a few plugins, and nobody had developed something similar. Instead, its user base grew many times bigger than I would have ever expected.

Naïvely, I didn't consider that many of them would have lots of different needs and demands that didn't fit within that model, and before long, I found myself adding features that I initially rejected: Daily Notes support, "Use when opening normally", and retaining notes in the sidebar, among others. Hubris and myopia are powerful things.

Those additional users and extra bells and whistles are nice for bragging rights, but with them the plugin also grew massively in lines of code, complexity, and features. I learned a lot, but gained a lot of extra responsibility as well.

Side Note: Dataview in Homepage

My TiddlyWiki homepage also had several other special properties - the time of the latest edit made to the wiki, and the total number of tiddlers that existed in the wiki. In TiddlyWiki, this is accomplished like so:

<b>Last updated on <$list filter="[!is[system]!has[draft.of]!sort[modified]limit[1]]"> <$view field="modified" format="date" template="DDth MMM YYYY at hh12:0mmam"/> </$list></b><br>
<b><$count filter="[!is[system]]" /> pages on this wiki</b>

Although I considered creating a plugin to implement a system of magic words similar to TiddlyWiki's widgets, I realised that it was very easy to write something equivalent with Dataview's built-in JavaScript capabilities:

let all = dv.pages("");
let lastmod = all.sort(a => a.file.mtime).last().file.mtime.toFormat("dd LLL yyyy 'at' h:mma");
let count = all.length;

dv.paragraph(
    `<div class="nv-subtitle">Last updated on ${lastmod}<br/>${count} pages in this vault</div>`
);

Homepage and Dataview are a popular combination nowadays, with many flashy and photogenic homepages far beyond what I ever imagined. Although they were intended to be used together from the very start, I later added an extra setting to ensure that Dataview statistics are always refreshed (depending on your use case, the original refresh rate may be sufficient).

Optimisation

Although nothing Homepage does is particularly intensive, it has a very high performance bar: users shouldn't have to wait to interact with their homepage. Opening a file may be quick, but when wrapped in Obsidian's panes and models it can take a little longer. And it's always prudent to avoid useless and repetitive work.

The primary path for Homepage - the original method of clearing extant notes, and opening a new note - is designed to be simple, and to involve little intensive work. Although there's a lot more conditionals and steps that there initially were, the path from the initial HomepagePlugin.onload() to the actual opening of the vault should be as straightforwards as possible. Ideally, anything extra is gated behind a sole condition which then leads to the implementation, and any additional processing is only done then.

Obsidian's core functions are closed-source, but they can still be introspected via the Chromium developer tools. For many plugins, this isn't necessary, and you can stick to the intended model of being handed the API as a mysterious black box, where all the difficult stuff is out of sight and out of mind. But for Homepage, it has been very helpful.³

As an example, let's look at the code that closes all other tabs when "Replace all open notes" is selected. We want to close all tabs on a certain list of known tab types, as Obsidian has tabs like the file browser we want to retain.⁴ This seems simple: there is the function app.workspace.detachLeavesOfType, so we run through the types of leaves we want to close:

CLOSED_LEAVES.forEach(t => this.app.workspace.detachLeavesOfType(t));

What isn't apparent from the public-facing API is that Obsidian keeps a list of all the open leaves, but it doesn't track them by type. Usually, the user opens and closes tabs a lot more than they do something that requires tabs of a certain type, so tracking tabs by type is suboptimal. Instead, Obsidian simply does this:⁵

function getLeavesOfType(viewType: string): WorkspaceLeaf[] {
    let leaves = [];
    iterateAllLeaves(leaf => {
        if (leaf?.view?.getViewType() !== viewType) return;
        leaves.push(leaf);
    })
    return leaves;
}

function detachLeavesOfType(viewType: string): WorkspaceLeaf {
    for (const leaf of this.getLeavesOfType(e)) {
        leaf.detach()
    }
}

Obviously, we don't want to be iterating through the whole set of leaves multiple times, as it's an expensive operation. Instead, we can simply call iterateAllLeaves directly, as it's also a publicly exposed function.⁶ In the callback, we check whether each leaf has a type we want to get rid of once:

let leaves = [];

app.workspace.iterateAllLeaves(leaf => {
    if (CLOSED_LEAVES.contains(leaf?.view?.getViewType())) leaves.push(leaf);
});

leaves.forEach(l => l.detach());

In fact, iterateAllLeaves just calls a few other internal functions to iterate over different parts of the window. If we narrow it down to iterateRootLeaves, this also ignores the side panels containing the file browser and its cohorts. The tradeoff is that we can't pick what tab types to close, but the few special tab types can be handled separately.

let leaves = [];

app.workspace.iterateAllLeaves(l => leaves.push(l));
leaves.forEach(l => l.detach());

But it still isn't ideal. We've closing each tab separately, so the visual state is wastefully updated after each modification.⁷ Instead, the changeLayout function modifies it in one fell swoop. When looking at the code for the popular built-in Workspaces plugin, which is proven to work without many hitches, we can see it is used there too.

Development and testing

Most plugins perform their work after the vault is loaded in response to user action, so much of the API is predicated on giving Obsidian time to set up. Homepage acts differently - while it can be manually triggered by user action, it is usually automatically launched on startup. If Obsidian is still loading, Homepage can break in difficult to reproduce ways without carefully considered and tested code.

The main method of testing Obsidian plugins to use an off-the-shelf JavaScript testing framework and mock Obsidian's proprietary application code. But for Homepage, which depends on behaviour of Obsidian functions which may not work predictably while the vault is still loading, this does not work. Additionally, while many other plugins have complex logic which can easily be extricated from parts that interface with Obsidian, Homepage performs almost all its actions by putting together core Obsidian functionality. Therefore, Homepage uses a custom test runner that runs inside the Obsidian vault instead.⁸

While Obsidian can launch vaults in an automated fashion, it can only do this for known vaults (as of this writing). Therefore, the test vault must be opened manually once. Then the rest is automated via an augmented version of the plugin, which automatically runs through different test scenarios after the vault is initialised. It handles basic testing functionality, like failing on errors, built in methods for assertion accessible from each test function, etc. The testing cycle runs like so:

The build script builds the plugin using ESBuild, substituting the usual HomepagePlugin for its HomepageTestPlugin subclass.
It sends a custom URI to Obsidian, telling any previous test instances to quit. Then it uses another URI launching a vault with the newly built augmented plugin.
The build script terminates, and logic is handed off to the plugin, which downloads the latest versions of other plugins which the tests interact with. It then runs the tests and displays their results.

Each test suite is its own class, which are all loaded into HomepageTestPlugin. A basic test looks like this:

async replaceAll(this: HomepageTestPlugin) {
    await this.app.workspace.openLinkText("Note A", "", false);

    this.homepage.data.manualOpenMode = Mode.ReplaceAll;
    this.homepage.save();
    this.homepage.open();

    const file = this.app.workspace.getActiveFile();
    const leaves = this.app.workspace.getLeavesOfType("markdown");
    this.assert(file?.name == "Home.md" && leaves.length == 1, file, leaves);
}

Additionally, Homepage incorporates a few additional functions which are included in non-production builds which are designed to be easily accessed in the console for debugging. With ESBuild, these are automatically excluded from production builds:

declare const DEV: boolean; 
if (DEV) import("./dev");

homepage.ensurePlugins: Obsidian doesn't have a public API to add and manipulate other installed plugins - which makes sense, as it'd be really easy to use for nefarious purposes. However, a user's particular plugin setup often needs to be emulated to reproduce issues they are experiencing. This function uses a reverse-engineered extension of the Obsidian API to download (and optionally enable) a list of plugins.⁹
9
The test suite initially used its own logic in the build script to directly download and install the plugins, but now also uses this function for consistency with Obsidian's logic.
homepage.loadDebugInfo: This is associated with a Copy debug info button in Homepage's settings and a command. Unlike Obsidian's native debug info command, this info is intentionally structured as JSON so it can be loaded into the function, which installs and loads the appropriate plugins, and modifies all Homepage settings and relevant core Obsidian settings.

User experience

One of the most challenging parts of making Homepage isn't making features work, or deciding how to implement things, but designing how users interact with the plugin. Although the core workflow is very simple, the user interaction for complex settings needs to be intuitive.

A hallmark feature of Homepage 3.0¹⁰ was supposed to be the ability to create and switch between arbitrary number of homepages. Any of these homepages could be set as a desktop or mobile homepage, and possibly as a homepage to be opened up on startup, or to be opened via commands or buttons (with the user being able to create an arbitrary amount of them, instead of just one). The feature for a manual opening mode would be obviated: instead, the user would just create a whole new homepage.

This would open up a whole new set of use cases for the plugin, and plenty of people who don't want something set automatically on startup would find it useful. In fact, the data model for Homepage 3.0 and later is designed around this, and it is used for having a separate mobile homepage:

{
    version: 4,
    homepages: {
        "Main Homepage": {
            value: "Home",
            kind: Kind.File,
            openOnStartup: true
            ...
        },
        "Mobile Homepage": {
            value: "Mobile Home",
            kind: Kind.File,
            openOnStartup: true
            ...
        }
    }
    ...
}

But the main reason why the feature hasn't been implemented is the difficulty of designing an intuitive user workflow for it. Having an interface that is intuitive, easy to understand, and has no extraneous details is more important than complicating it for a feature that a good portion of users won't care about or use.

Right now, making sure that the homepage doesn't close all other tabs when opening it from a command is as simple as setting a "manual opening mode". Making it the responsibility of separate homepages is easy to code - most of the work has already been done - but makes for a more annoying user interface. Every time the user wants to change another unrelated setting, they now have to change it for two homepages. I could create a default homepage that all the others inherit from, but that's more added complexity that users have to wrap their heads around. Sometimes simple is better.

One of my favourite pieces of user interface for Homepage is the command box. The add button is intentionally in line with the commands, signifying that it's in the place of where an added command is going to go. The inline nature of the different command pills nicely indicates how the commands are run in order one after another, while being more compact than simply dedicating a row to each command. Plus subjectively I think it looks pretty.

A challenge was making it support additional options in version 4.0. In versions beforehand, the commands UI looks like this:

The commands UI, as introduced in version 3.0.

4.0 added the ability to set certain commands as only activating during startup or when opening the homepage manually. This was intended to serve some of the same purposes as creating arbitrary homepages - people might want to use commands at certain times but not others. Initially, I considered making this option a dropdown on a separate line, in slightly smaller text:

Although these mockups were made in Affinity Designer post-facto, each layout was actually tested.

But in practice, these dropdowns are extremely small and hard to target. If they were bigger, they wouldn't be subordinate to the main titles, and if you made the whole thing bigger, it would take up too much space. Plus, this removes the visual conveyance of the commands being in sequential order - the user is now reading the dropdown and buttons on the bottom, then going back to the top, then back down, and so forth.

My next solution was to add icons for the different states. I also gave the non-default settings an accent colour to help them stand out, and to convey that something is "active" that isn't the normal setting. It looked like this:

It wouldn't be unreasonable to assume that ⏻ means that the command is executed when closing your vault.

This is definitely more compact and less obtrusive. But even after testing a lot of icons, it's difficult to tell what they mean, and the small size means they've difficult to notice. While it's a fairly advanced feature, so a size smaller than the default Obsidian UI elements is acceptable, this is too far in that direction. Eventually, I went with this:

The final commands UI in version 4.0 and later.

At first, I considered this somewhat non-ideal: the button changes size, and using text is almost cheating! But the button needs to be non-intrusive for the majority of users which aren't interested in an advanced feature, but distinct and descriptive for those who are using it. So having it change size is kind of a necessary evil, and there's precedent for using text in this way. The icons almost stayed in, but in such a compact UI I found they were additional visual noise, so they were dropped at the last minute.¹¹

1
Equivalent to a wiki page or note.
2
In addition to the sidebar, which has a more comprehensive listing of different tiddlers/notes in both Obsidian and TiddlyWiki.
3
Of course, one should keep in mind that internal APIs are internal for a reason, and that their performance characteristics are subject to change with little notice.
4
i.e. "markdown", "image", "pdf", etc. Additionally, a few third-party plugins' tabs had undisclosed side effects, and Obsidian has certain tabs like release notes that needed to be treated separately.
5
This isn't the exact code used, of course, as that is proprietary.
6
Many Obsidian plugins, Homepage included, do use some private APIs. But it's still good to avoid them where possible.
7
Plus the user sees each tab flicker out of existence, which is far from a seamless experience.
8
This could be considered similar to something like Playwright. In Obsidian-land this is fairly unique AFAIK; I'm not aware of any other plugin which does this.
9
The test suite initially used its own logic in the build script to directly download and install the plugins, but now also uses this function for consistency with Obsidian's logic.
10
Initially revived for Homepage 4.0 as well.
11
But they still exist commented out.

Unicode is Worth It

2023-10-27T00:00:00+12:00

In computing, one guideline has came to define how text is encoded: the Unicode Standard. The vast majority of letters you see on the screen - on a website, Word document, or in the file system - uses the UTF-8 encoding of it.

Being a nearly universal standard, it receives plenty of criticism. In fact, I was being a little misleading with the title, since I am not above criticising it myself. Plenty of Chinese, Korean, and Japanese computing experts have sharply condemned Han unification, and for the most part I agree with them. And as plenty of developers know, Unicode's complex historical context has lead to a design that is at times inelegant and inconsistent: Ω is not the same as Ω.¹ Sometimes, people even advocate doing away with it entirely, and reverting back to multiple encodings. For instance, from an old version of the GNU moe manual:

Replacing all the 8-bit character sets with Unicode is like trying to simplify transportation by standardizing on the same kind of (excessively) large vehicle. I.e., forcing everybody to use a vehicle as large as the largest vehicle anybody may need. Just like owning a normal car may be orders of magnitude cheaper than owning a four-engined airliner, text tools using an 8-bit character set may be orders of magnitude more efficient than those using Unicode.

Or comments by the creator of the D language, Walter Bright:

The imposing is inflicted by the Unicode standard on everyone in the world who have no use for never ending new invented encodings for the same thing... What should give pause in advocacy for the tarpit of Unicode is its unimplementability. That's a giant red flag that something went horribly wrong.

This is a position I strenuously disagree with - a universal character set and encodings that use it are good things.

Core to many of these claims is the idea that different languages should use specialised encodings. Unicode, according to these critics, has accreted unfathomable complexity in service of an impossible goal. And indeed Unicode is complex - but replacing it with multiple encodings would just hand most of the complexity off to a different source. Most OSes handle strings at a fundamental level. Instead of string facilities in operating systems and programming languages having to handle the minutiae of Unicode, they'll have to handle the complexities of different encodings. Imagine that instead of one kind of string in UTF-16 (Windows)/UTF-8 (most Unix), there’s now around 10, all of which have to interact with core OS services. And all of them operate on their own standards, instead of the singular body of Unicode standards.

Even then, this is assuming that different developers even bother to implement it. In our current Unicode world, many still don't handle complex writing systems such as Arabic very well - a fact that is commonly pointed out by detractors of Unicode to admonish its complexity. Let's look at the below Arabic text:

نيوزيلندا

This is legible to your average Arabic speaker. Unfortunately, it isn't when incorrectly rendered as something like:

ن ي و ز ي ل ن د ا

It's easy to blame Unicode, but developers wouldn't have the impetus to handle different languages at all without it. Unicode at least forces compatibility with some form of text, and badly-rendered text is better than no text at all. Given the dynamics at play, the latter would be inevitable with the hypothetical Unicode-replacement.² Currently, a person can transmit Arabic that was badly rendered by one system to another one that competently renders it. But if they can't enter their native language in the first place, then - to use a technical term - they are stuffed.

Unicode's rules also provide a guideline for correct implementation of rendering these languages: there are always inherent difficulties with rendering scripts that are more complex than simply letters side by side, and it makes more sense to account for that in a basal manner. Since developers have to build a non-zero implementation of Unicode features for many things English speakers use and expect, such as emoji, there's an incentive for developers to handle global languages properly. With many different encodings, many simply wouldn't bother.

There's also the issue of mixing different languages. Due to the Western world's preeminent position in the global cultural sphere, a lot of colloquial speech in different languages freely combines various writing systems. Anecdotally, I'm in communities with non-English speakers, and many of them casually mix English and their native language. Even if they don’t, a lot interact with multiple scripts for, say, speaking Czech at work but playing in English on Steam. And this mixing occurs in more formal contexts as well, such as official names, English translations, abbreviations, or technical terms. For instance, a good portion of corporate Chinese, Japanese, Cyrillic, or Arabic text is interspersed with English brand names:

ニンテンドー3DSシリーズおよびWii Uの「ニンテンドーeショップ」

Sure, one could switch between encodings for this - but it's a lot of rigmarole for a task that is far more common than the majority of English speakers would expect.

People will also say that multi-byte characters are bad and should be avoided. This is a very tempting claim to make, as a lot of string handling in low-level programming languages would suddenly become a whole lot easier. Before Unicode became popular, the assumption was generally that a variant of ASCII would be used, where each character would neatly fit in a byte. Much of Unicode's complexity comes from the fact that to store many different characters, it has to encode most characters in two or more bytes.³ So if this was avoided, it would greatly simplify things... except, not really. Although this would work for English and the ASCII character set, languages such as Chinese and Japanese have heaps of characters - a conservative estimate would be at least 200,000 for the former, which is more than is able to fit in a byte, or even two bytes. Systems that maintain the ideal of one byte simply don't work in many places; this might have been easy to ignore in a pre-Unicode era, but in an increasingly globalised world, it's not.

Despite what some people say, supporting non-Latin scripts isn't a nice-to-have. It's very easy in an English-speaking world to dismiss the importance of other languages. But Mandarin Chinese is the second most popular language in the world, and has almost a million people who are native speakers. These people deserve to not only have basic operating system support for naming files, writing documents, and reading web content efficiently, but also be supported in applications that perform more specialised tasks. Even if you've building a tool for an obscure language or niche hobby, or cutting corners and trying to get your product ready to market ASAP, you'll never know who ends up using it.

In the early days of Unicode, multi-byte encoding was also criticised for being inefficient at storing text. Initially, most Unicode software used the UTF-16 encoding, which stores every character in either 16 or 32 bits. But most implementations nowadays use UTF-8, which preserves single-byte encoding for ASCII characters; this also has the advantage of some backwards capability with programs that assume that a byte is coterminous with a character. Only scripts used by other languages, such as the aforementioned Chinese and Japanese, are relegated to higher amounts of bytes. Some people still criticise this as prioritising Western languages, but the amount of these characters is so great that many would still take up multiple bytes even if they were given first priority. And I believe these languages being segregated into their own second-class encodings with limited support would be far more deleterious than the additional bytes.

Another complaint is that Unicode has a whole bunch of useless characters. Typical examples given include:

Emoji: 😖😵‍💫😳😱
Mathematical lettering 𝑤ℎ𝑖𝑐ℎ 𝑖𝑠 𝑜𝑓𝑡𝑒𝑛 𝑢𝑠𝑒𝑑 𝑜𝑛𝑙𝑖𝑛𝑒 𝑓𝑜𝑟 𝑑𝑒𝑐𝑜𝑟𝑎𝑡𝑖𝑜𝑛
Enclosed characters 🅻ⓘ⒦🅴 🅃⒣🄸Ⓢ

Due to the vast amount of Unicode characters - mostly Chinese, but plenty exist from other languages as well - any encoding that stores them all must be able to have a maximum length of at least 32 bits. But while the amount of characters cannot comfortably fit into a smaller size, 32 bits still leaves heaps of empty space. So most of the extraneous symbols are, to be quite frank, harmless. If you don't like them, you could almost pretend that they don't exist.⁴ But in fact, they can often be helpful: while people often consider 𝕏 𝖃 and 𝐗 to be useless decoration and an inappropriate usage of Unicode, they often have very distinct uses in mathematical equations.⁵ If other characters deserve encodings due to their semantic meaning, these do as well, and their codepoints have plenty of practical applications, such as screen readers or contexts without rich text.

What is undeniably a negative is that Unicode has multiple encodings for the same symbol. But despite it causing issues now, it was initially a very useful feature. For Unicode to gain wide adoption, it needed to be a lossless conversion target; i.e. it needed to have everything that previous encodings had. While the result may not be optimal in the present, I think it goes without saying that the alternative of Unicode and several other individual encodings would be even worse.

Similarly, the vast amount of characters leads some to claim that nobody can possibly implement all of Unicode. But this is beside the point. Nobody could implement all of the internet cabling that spans the globe. Nobody could implement a lot of things as a single unit, but our collective force allows the world to work cohesively regardless. The same is true here: plenty of Unicode libraries exist, and just like other complex aspects of programming, people can build on the shoulders of the metaphorical giants. On the user-facing end, most modern applications allow fallback fonts. If the user needs certain characters, they simply obtain a font that includes them. If they don't, then it's no skin off their back. In many cases, the OS doesn't even need to know about these characters, so new glyphs can be added and used with minimal pain. Unicode may have a lot of complexities, but this in particular is elegant and simple.

It's easy to forget with Unicode's predominance that there was once a time before it. We've tried living in a world without Unicode; but even in that time, humans still communicated in a vast arrays of characters and scripts. The multifarious encodings only made that more difficult; hence Unicode being created in the first place. Unicode is only making sense of the world that already existed, banishing encoding conversion errors to a relic of the past and making global communication easier. It is just a reification, an actualisation in a sense, of the hundreds of years of human history that already exists.

Review: Cassette Beasts

2023-08-01T00:00:00+12:00

I didn't get the opportunity in this review to write about it, but the game also features a cool cassette-based battle UI.

For a long time, I've been following the open-source Godot Engine with keen interest. Although I've never released any games myself, I agree with their vision of an open software-based game creation toolkit and am keen to see it succeed. So when two-person indie team Bytten Studio released Cassette Beasts using it I decided to check it out.¹ I had some experience with their previous game Lenna's Inception - which I liked, but ultimately couldn't finish due to bugs in its Java-based runtime and procedural generation system. Thankfully, they ditched both of those for Cassette Beasts, allowing me to play it to completion.

Most indie monster-catching games tend to be quite similar aesthetically to Pokémon - not that it's their fault. The billion-dollar franchise casts a long shadow over any potential competitors, and any customers will always have their nostalgia as a nigh-intractable benchmark. Cassette Beasts makes great pains judiciously distinguishing itself to alleviate this. Unlike many of its cohorts, its setting is pretty unique: adults (as opposed to children) are plucked out of multifarious timelines and universes and brought to the mysterious island of New Wirral. Although there are the requisite 128 different monsters to collect, they aesthetically take a rather different direction from Pokémon; many being a melding of man-made and biological artifices almost reminiscent of the fauna of Mother 3. Players are supposed to "record" these using cassettes, and transform into them in battle to do direct combat. This is a very cool thematic choice, albeit it is a bit weird at times; thankfully the game nicely handwaves it away rather than trying to make unsatisfying excuses.

Still, it leaves a lot of questions. What if a player character transforms outside of battle? How long is a transformation maintained? Can they get stuck? Do the Traffikrabs and Salamaguses (Salamagi?) in the wild ever encounter a transformed human and get confused? Perhaps I am overthinking this, but there is still a whole lot of story potential left unexplored.² The same can't be said of New Wirral: the game gives a satisfying and interesting, if a bit clichéd on a certain level, response to the mysteries of the island's existence. And as a whole, it contains a whole lot of narrative meat and mature heft which doesn't exist in many monster-catching titles.

The gameplay also contains a number of welcome innovations. Types are similar to the classic Pokémon formula, but different attacks apply status effects based on you and your opponent's types. This results in satisfying strategic ploys: if you choose the wrong combination, many available moves will end up giving your opponent a positive effect, so you'll either need to discard a turn switching to another monster, or factor the buff your enemy receives into your planning. Moves can also be swapped and changed, creating even more tactical variations, at the cost of making overpowered builds a tad too easy. Each member of your two-person team also has an AP meter: they accumulate a certain amount of AP per turn, and can either use it all immediately, or use a less expensive move and save the remaining AP for later moves. This creates immensely rewarding dynamics, and is honestly one of the best battle systems I've seen in an RPG; combined with the aforementioned type-based attacks, it lends a large amount of depth to the game. A really neat mechanic that also enhances this is the "fusion meter"; when filled, you can combine your monster with your partner's for the duration of the battle.³ This fills up your AP really fast, letting you use really powerful moves each turn, and doubles your statistics. However, it leaves you more vulnerable as well, as enemies can all focus on a singular target and you are limited to one move a turn to fight back.

Unfortunately, all these mechanics become more of a burden when traversing areas with under-levelled beasts, which is a frustrating experience: they still try to approach you, yet are very easily beatable, their battle animations are long and repetitive, but the only item that lets you avoid battles is a consumable (there is a level scaling option, but it affects the rest of the game as well). And while the game is harder than the unconfronting easiness of Pokémon, it still feels a bit unchallenging at times, and I ended up wishing I had chosen a more difficult AI setting from the get-go.

Your party is (usually) made up of a customisable player character and a partner. Different partners are encountered throughout the game, and each has a unique quest associated with them, in addition to a few independent quests that spawn in the overworld. Compared to some RPGs, the quantity of non-story quests can sometimes be a bit threadbare, but the game was made by a small team, so it's understandable. As you fight alongside your partner and rest at campfires with them, you increase a relationship meter,⁴ progressing the narrative and granting additional gameplay powers, eventually even having the option of forming a romantic relationship.

This adds a necessary element of narrative dimensionality that helps give purpose to the whole conceit of capturing hundreds of disparate creatures, and all the partners are well-written and distinct. My only qualm with them is that there could be a bit more late-game dialogue - again which is the side effect of an indie team. This all factors into the overarching plot, centered around the player attempting to leave New Wirral (albeit they still have the option of beating ~~Gym Leaders~~ Rangers as a side quest). Unsurprisingly, it doesn't end up being a cakewalk, and many diversions and entertaining scenarios play out along the way, as is requisite for a good RPG story. I don't want to spoil too much, but there are some really interesting and unique monsters and setpieces that you encounter.

New Wirral is a rather small island; its meagre size is successfully compensated for by a tightly packed environment. There are no wide open expanses here: instead, every corner is packed with multiple chests, buildings, or points of interest, and the game's environments are punctuated with a large array of biomes to explore. Of course, these include monsters to capture, alongside "rogue fusions" of several different varieties for more challenging fights. The overworld also has full physics simulation, which is a rather odd decision by the developers. This choice has both upsides and downsides: it produces some neat puzzles and makes walking and jumping around that little bit more fun, but occasionally doing a task that would be straightforward in a more traditional RPG overworld environment requires a bit of finagling or guessing to arrive at the intended solution.

As the player makes their away across the island, they utilise their fancy physics by unlocking different abilities (e.g. swimming or electromagnetism), which allow them to reach previously inaccessible locales. Some are optional, while others are required to progress; unfortunately a few of the latter are difficult to obtain naturally until coming across the right rumour from a townsperson. Overall though, it grants a nice sense of progression usually only obtained in other titles by levelling up: flying halfway across the island in the late game with previously impossible obstacles beneath really reminds me of how far I've came.

The visuals of the overworld employ an interesting style - although the characters and monsters are two-dimensional, they inhabit a three-dimensional world. For the most part this works very well and is excellently done; however, the limited size of its pixel art means that its character sprites can often lack the instant appeal of those seen in more recent Pokémon games. For non-player characters, the game successfully compensates for this by featuring portraiture by Sami Briggs which excellently fleshes out their vibe and personality. This is obviously not possible for the player character - I had a bit of trouble coming up with an appealing one at first, and it took me quite a few tries before I found something I liked.

Conversely, the ambient soundtrack, by Joel Baylis, the brother of one of the developers, hits all the right notes. It's further enhanced by vocals by singer Shelly Bailey, which play when you've in important fights or inside buildings. There's only one other title that I've played which uses this technique: magical school RPG Ikenfell,⁵ but I find it to be immensely entertaining (and a welcome reprieve from the blandness of many video game soundtracks) and wish many more games would have it. It does result in minor fights being sonically repetitive; a few more in the mix would help liven things up, but it can always be disabled and it's still better than not having it.

All these physics simulations and pretty visuals have an impact on the performance however, which can be a bit suboptimal at times, though it's never so bad that it impairs enjoying the game. As the player sees more of New Wirral, they experience a noticeable (yet again, hardly game-breaking) slowdown. And once they have explored all of the map,⁶ a journey across it will inevitably be obstructed by a short intermission in the form of a loading screen. Fortunately, this can be alleviated by turning down the graphical settings, but I feel a computer with my specs should be more than powerful enough to run a game of this intensity without doing so, so it's still a little disappointing.

Console players might be in for a more difficult time, though: the game had showstopping slowdowns, bugs, and glitches on Nintendo Switch on launch, and while this has been improved upon in the 1.2 patch, it still isn't perfect. Apparently, it runs on the 3.0 branch of Godot, and while this may initially seem like a bad omen for the engine's console potential, both general performance optimisations and console-specific improvements are supposed to be present in 4.0.⁷

Inevitably, the Rangers have a variety of post-game busywork that needs doing, and much of it is doled out as quests that devolve into needless grinding. While some players have found this fun, needless to say I am not one of them. This is a rather disappointing design decision, since there are a number of bosses and encounters only accessible after doing a whole lot of it. Another post-game disappointment that I imagine many players will be put off by is the lack of player-vs-player combat, even if it's not something I personally care about. The developers have promised this will be added in an update though, and their track record has so far been great: a free patch has already added eight new monsters and a minor new location. In the meantime, I still recommend anyone interested in monster-catching games checks this out. It's a great showcase for Godot's capabilities, and although there's no chance it'll dethrone Pokémon in people's hearts and minds, the developers make no pretences of doing so - there's plenty of room for both in the world.

4.6 out of 5 Novov Affirmation Points
Star Get! Novov really likes this!

1
Cassette Beasts is the first Godot game to release across multiple console platforms and PC, or so I am told.
2
Except, perhaps, in fanfic if that's your jam.
3
This is similar to some Pokémon fangames, though it's only possible in battle, which will disappoint many people. Given the game has quite a few mechanics already, perhaps that's for the best though.
4
There's a lot of meters in the game, isn't there?
5
Ikenfell is also really good in other aspects - you should check it out as well.
6
Which nets the requisite achievement, of course.
7
Though it is unlikely that Cassette Beasts in particular will make the upgrade, as it is reputedly quite difficult, and there is already a veritable array of user mods based around the 3.0 version's API.

Mixed Memories

2023-07-09T00:00:00+12:00

For most Mac users, determining the amount of memory used is pretty simple. You go into Activity Monitor and have a look at the Memory tab.

Activity Monitor even gives us different subcategories of memory usage, which is nice. But as we will see soon, very simplified.

The more technically inclined might go one step further, and use something like iStat Menus or neofetch. I'm too cheap to buy a license for the former, so let's have a look at the latter.

Looks like memory to me.

But they'll quickly notice a small problem: the amount of used memory can sometimes be different.¹ And while in this case, one is in mebibytes and the other in megabytes,² the difference still doesn't line up when you do the conversion. So let's go one step lower and query the amount of memory by compiling a little executable in a trendy programming language such as Rust.

use sysinfo::{System, SystemExt};

fn main() -> () {
    let sys = System::new_all();

    print!(
        "{mem_used} bytes / {mem} bytes",
        mem_used = sys.used_memory(),
        mem = sys.total_memory()
    );
}

Compiling test_crate v0.0.1 (file path redacted)
    Finished dev [unoptimized + debuginfo] target(s) in 0.26s
    Running `target/debug/test_crate`
15674580992 bytes / 17179869184 bytes

Well, that isn't helpful. Let's actually have a look at going on here. Unfortunately, Activity Monitor isn't open source,³ but we can have a look at the internals of the neofetch source code and the sysinfo crate I used. I'm going to start with the former.

At its core, Neofetch is a one-file Bash script that handles all its functionality for a variety of (largely Unix-like, but also Windows) operating systems. It is divided into different functions, each of which is used to obtain the appropriate statistics for the respective category. We want the get_memory() function. It's divided into cases for different operating systems, so we'll grab the section of code that gets the macOS info.

"Mac OS X" | "macOS" | "iPhone OS")
    mem_total="$(($(sysctl -n hw.memsize) / 1024 / 1024))"
    mem_wired="$(vm_stat | awk '/ wired/ { print $4 }')"
    mem_active="$(vm_stat | awk '/ active/ { printf $3 }')"
    mem_compressed="$(vm_stat | awk '/ occupied/ { printf $5 }')"
    mem_compressed="${mem_compressed:-0}"
    mem_used="$(((${mem_wired//.} + ${mem_active//.} + ${mem_compressed//.}) * 4 / 1024))"
;;

As one can see, in typical Unix fashion, it calls a number of small utilities to gather the amount of used memory and total memory. In this function, they are sysctl, which is a command-line tool that allows querying system statistics, and vm_stat, which lists off various Mach kernel⁴ memory statistics.

First, it grabs the total memory and divides it twice to convert it into mebibytes. It then pulls together wired memory, active memory, and compressed memory to compute the used memory. Since the figures it uses are in pages, it then uses the page size⁵ to convert these pages into bytes, and then divides it as it did with the total memory.

Now, let's look at the Rust sysinfo crate I used earlier:

Much of the library is composed of OS-specific code that lives in its respective folder. In our case, that's src/apple, for macOS and iOS code. In particular, we want the functions under SystemExt, so we'll grab src/apple/system.rs.

// get ram info
if self.mem_total < 1 {
    get_sys_value(
        libc::CTL_HW as _,
        libc::HW_MEMSIZE as _,
        mem::size_of::<u64>(),
        &mut self.mem_total as *mut u64 as *mut c_void,
        &mut mib,
    );
}
let mut count: u32 = libc::HOST_VM_INFO64_COUNT as _;
let mut stat = mem::zeroed::<vm_statistics64>();
if host_statistics64(
    self.port,
    libc::HOST_VM_INFO64,
    &mut stat as *mut vm_statistics64 as *mut _,
    &mut count,
) == libc::KERN_SUCCESS
{
    // From the apple documentation:
    //
    // /*
    //  * NB: speculative pages are already accounted for in "free_count",
    //  * so "speculative_count" is the number of "free" pages that are
    //  * used to hold data that was read speculatively from disk but
    //  * haven't actually been used by anyone so far.
    //  */
    self.mem_available = u64::from(stat.free_count)
        .saturating_add(u64::from(stat.inactive_count))
        .saturating_mul(self.page_size_kb);
    self.mem_free = u64::from(stat.free_count)
        .saturating_sub(u64::from(stat.speculative_count))
        .saturating_mul(self.page_size_kb);
}

Further down, the used memory is computed by subtracting mem_free from mem_total. Makes sense, I guess. As for the calculations themselves, they are obtained via macOS system calls, which is more efficient than launching a number of Unix command-line processes. The total memory is retreived using the same system call as Neofetch (hw.memsize), but it uses the system function sysctlbyname directly, rather than the intermediary sysctl terminal utility. Obtaining the free memory is done with the host_statistics64 function, which is what vm_stat uses underneath the hood as well. However, what it does with those values is different than Neofetch: the crate obtains the system's internal count of free pages, and then (saturatedly) subtracts speculative pages from them.

Speculative pages hold data grabbed ahead of time that the kernel thinks currently running processes might need later. But as the comment in the code says, they aren't used by anyone yet, and they've also pretty easily evicted if the memory is needed for more important uses, so they aren't really "used" in a way that causes problems. In other words, the Rust sysinfo crate's quite a bit stricter in its definition of what counts as "free" memory: any page that is occupied so far, even if it's not actually used by a program yet, is considered "used". The line between free and used memory is blurrier and more subjective than it may initially appear. So let's clear few things up.

Memory size, as you probably know if you've reading this, is the amount of memory (to be specific, RAM, or short-term data, as opposed to files on disk) a computer can store. It can be obtained via sysctl -n hw.memsize.
Page size is how big a page is in bytes. On Intel Macs, it's 4096 bytes (4 KiB); Apple silicon Macs are four times larger at 16 KiB. It can be obtained via sysctl -n hw.pagesize or the top line of vm_stat.

Free memory in technical terms is memory that is being used for absolutely nothing.⁶ It can be obtained by vmstat's "Pages free"⁷ section or sysctl -n vm.page_free_count (like sysinfo, these counts exclude speculative memory).
Speculative memory is, as stated above, memory that the kernel thinks currently obtained processes may need later, but can be easily evicted for more space. It can be obtained by vmstat's "Pages speculative" section, or sysctl -n vm.page_speculative_count.
Wired memory is memory that is used by the kernel to run essential system processes. It is essentially occupied by the kernel and cannot be freed. It can be obtained by vmstat's "Pages wired down" section, or "Wired memory" under Activity Monitor's Memory tab.
Active memory is memory that is being used right now. As in, right this moment, while you've reading this. It can be obtained by vmstat's "Pages active" section.
Inactive memory is memory that isn't used right now, but could be needed, and again can be evicted for more space if necessary. It can be obtained by vmstat's "Pages inactive" section.
- Compressed memory is inactive memory that is compressed to save RAM space. It can be obtained by vmstat's "Pages occupied by compressor" section, or "Compressed" under Activity Monitor's Memory tab.

Anonymous memory is memory that isn't connected to a file on the file system (i.e. is manually allocated by applications). It can be obtained using vmstat's "Anonymous pages" section, and is roughly equivalent to sysctl -n vm.page_pageable_internal_count.
File-backed memory is the opposite of anonymous memory: memory that is connected to a file. It can be obtained by vmstat's "File-backed pages" section, or "Cached Files" under Activity Monitor's Memory tab.

Purgeable memory is memory that is designated by app developers as being safely freeable if the OS requires more space (and recreated again later when needed). It can be obtained via vmstat's "Pages purgeable" section.
Pageable memory is memory that can be paged to disk (swap) if the OS runs out of space and no other memory can be freed. In systems with sufficient memory, paging is very rare, but the classfication is still used internally. It can be obtained via sysctl -n vm.page_pageable_internal_count and sysctl -n vm.page_pageable_external_count. Swap is available as "Swap Used" under Activity Monitor.

Application memory is a high-level construct used by Activity Monitor that approximates core memory used by apps. Although the formula isn't publicly available, it appears to be anonymous memory that isn't purgeable.

The issue is obvious: different sources calculate the memory different ways. Neofetch adds wired, active, and compressed memory. The Rust sysinfo crate gives everything that is not strictly free. And Activity Monitor, although its' method isn't publicly available, seems to add application memory, wired memory, and compressed memory. As for which one is the most accurate, it depends on what you mean really. Perhaps sysinfo is the most strictly accurate, but it's very unhelpful for day-to-day usage.

1
This has actually been rectified in the Neofetch codebase, but a new version hasn't been released for quite a while.
2
Some people define storage sizes in terms of 1024-byte multiples, while others use a system based on 1000 bytes. Usually, this tends to depend on whether they have an incentive to show a higher number of KBs, GBs, MBs, and such. To stop confusion, standards bodies have redefined 1024-byte units as mebibytes (MiB), kibibytes (KiB), gibibytes (GiB), etc - though many manufacturers still don't adhere to such a distinction.
3
Shocker!
4
Mach is the name of the kernel that was eventually developed into the XNU kernel behind macOS. One of the key tasks behind a kernel like it is to allocate and manage memory.
5
Memory is divided up into units called pages internally by the operating system.
6
<insert tumbleweed gif>
7
The numbers in vm_stat are the amount of pages, while numbers obtained by sysctl are usually either bytes or pages.

Review: Omori

2021-06-14T00:00:00+12:00

The battle system in this game is heaps of fun.

This blog post deals with mental health issues.

When I was a little boy, I sometimes wondered: why do people get depressed? I was quite naïve sometimes.

Slowly, things changed though. As I grew older and (arguably) wiser, I slowly but surely succumbed murky depths of mental illness myself. It started off slowly, but soon right became wrong and left became right, Thoughts and reality started to blur together. Voices started echoing in my head, telling me everything I was doing was wrong - not just incorrect, but morally depraved. I'd never make anything of myself, and I'd be a failure for the rest of my life. I'd always be an awful person, and I'd never make anything of myself.

I tried to hold things in for as long as I could, to not disappoint both myself and my family. To tell everyone who doubted me that they were wrong. Eventually, though, the symptoms became too much for others as well, and I had to confine myself to my house...

In 2014, Omori was launched on Kickstarter. It was initially planned for a release date in 2015, so plenty of eager backers forked over their cold, hard, cash. Soon, it became apparent that wouldn't happen. News of engine troubles and changes in creative direction spread over social media, and many people didn't think it would release at all.¹ But to a lot of people's shock, it did eventually come out - in 2020, when many people were far more concerned with the minor issue of the coronavirus.² Personally, I'd say the wait was well worth it.

It's a psychological horror role-playing game about the titular child Omori. Living in a rather miserable white room, he often takes a trip to the colourful dream-like world outside. There, he plays with his friends Aubrey, Kel, Hero, and Basil, going on adventures and doing things that kids do. But at the start of the game, Basil has just gone missing.

Actually, let's start again. Omori is a psychological horror role-playing game about... Never mind. You could spoil yourself by, say reading the game's Wikipedia article³, but I would highly recommend you don't. Anyway, onto the game. While certain parts can be dark, this is balanced with a softer exterior; overall, the game takes plenty of cues from your EarthBounds and Undertales. An aura of juvenile wonder permeates many of the environments, in a way that feels a little familiar from my childhood. But just like real life, we all grow up; one has to confront the darker recesses of the world eventually. It's just a question of how and when.

Unlike the events depicted in Omori, I decided long ago that I wouldn't be stuck in my house for almost four years. Instead, I largely remained stuck in my house for a year. Big improvement. Though the game's plot differs from my experience in a lot of ways, many things in the game were familiar to me. Feeling like an outcast; a dreg of society. Having to hide fucked-up things that happened to me from other people.

Regardless of what ends up happening to them, the cast of Omori are largely empathetic and well-written. Both the main gang and side characters deal with their own issues that often tie into the central narrative fulcrum in a unique way. A specific highlight is a certain cetacean who pops up just before one of the game's dramatic moments. His depiction - a concoction of hilarity and zaniness - just oozes creativity.

As a role-playing game, the battle system is a largely turn-based affair. I'm a huge fan of classic turn-based JRPGs, and disagree with them often being maligned by modern gamers. Although it doesn't have the strategic chops to compete with the best of them, the combat is fun and challenging enough. But the real draw is its unique mechanics: status effects involve dealing with a triadic system of emotions. You have Happy, which pulls your turn forward, but at the cost of accuracy. Angry raises your attack but makes you more vulnerable as well. And Sad raises defence but puts you at the back of the turn list. Both enemies and party members can have these emotions applied to them by choice or not, and each one has another that it's strong or weak against. It's a fun twist that shakes things up, although it can be underused in later parts of the game. Your party's damage also accumulates, allowing you to deal powerful "follow-ups" that interact with a friend. Often they've too powerful and make things a little too easy: I was able to complete the game under-leveled. Despite that, they can still be really fun to use against enemies.

Speaking of the enemies, they've depicted in a hand-illustrated style that exudes charm and creativity. In fact, the whole game's art is simply amazing - there's no other way to describe it. It's able to hone in on the requisite playfulness when required, and make things properly scary for the more spoilery parts of the game. A lot of neat artistic touches and narrative elements attain another layer of meaning as you progress, and things reveal themselves in hindsight. Unlike the film I reviewed in April, it doesn't feel hackneyed in the moment either.

Scary stories used to absolutely horrify me as a kid. When making my many requisite trips to the library as a kid, the Goosebumps books were a no-go; I always sticked to the safety of known entities. Growing older, the fear of the unknown became replaced by a fear of the known. These days, I can read and watch metric craploads of horror content and hardly break a sweat. I'm still not a huge horror fan, but I find what I've been through in real life much more scary. Going crazy is a lot more tangible and horrifying than your monster du jour.

As a game that primarily deals with a fear of the known, Omori resonates with me a lot. Although it's a bit of an overused trope in indie circles, depicting this kind of stuff is no mean feat. Everyone deals with mental illness differently, and one person's "realistic" might be the next's "playing into harmful stereotypes in an exceedingly problematic way". While a certain knife initially made me turn my head, I found things were ultimately portrayed respectfully and realistically. The game juggles with heaps of issues in a way that is honestly pretty impressive for something made in RPG Maker.⁴ I actually forgot it was made in that engine sometimes; the level of thought and flair would be great for even a Unity title.

This amount of care is also invested into a veritable array of side-quests. Most of it is the usual fare, allowing the dedicated player to level up their party that much more and discover tidbits of hidden story content. For instance, you can find humorous quips on signs to put in a "Joke Book"; collecting them all provides an optional quest. But being the un-dedicated player I am, I mostly looked stuff up on the wiki afterwards. If there's one complaint I have, it's that the inscrutability and haphazardness sometimes also applies to the primary gameplay route, making it a bit frustrating to progress at times. If you've more easily scared than I and make a certain decision early on, you can even be locked into a certain narrative choice. But as someone who can be frustrated about getting the wrong ending, that moment is an exception to the rules. This isn't one of those games where you need to be watching every step so you get ending 45 instead of ending 46, and the important decisions are usually clear enough.

In Omori's final act, the results of whatever decision you make come back to haunt you for great or ill. Its ending is a real shock, something that ties all the narrative points and thematic beats of the game into something spectacular. In fact, it's easily one of the best endings I've experienced in a video game. Again, I won't delve into the details, since you should really be just playing the game.⁵ Yes, I'm saying that again - there's some things you just can't hide from. Some people can learn to deal with their issues; some cannot. But they'll always be there.

4.8 out of 5 Novov Affirmation Points
Star Get! Novov really likes this!

1
Kickstarter has gained a bit of a reputation as a grifters' paradise - a not undeserved one, given the profusion of blatant scams on the platform. But from my experience, video game failures on the platform tend to be less often scams and more often people who just don't understand the amount of work involved.
2
Or 5G, if you've an idiot.
3
Disclaimer: I wrote significant parts of said article.
4
As someone who's really into programming, I used to be of the attitude that people should just use proper game engines. However, such an attitude locks out a lot of creatives with imaginative and original ideas. In my opinion, it's really the result that matters; tools are ultimately incidental.
5
Don't get ahead of someone when crossing the river in the raft.

Review: Come True

2021-04-03T00:00:00+12:00

Unfortunately, Sarah (Julia Sarah Stone) might be frustrated at some of this movie's inconsistent plot points.

When I started this blog, I was envisioning some in-depth essays about computing and stuff.¹ So far, this hasn't panned out, and unfortunately (or fortunately, depending on your tastes) I feel lazy enough to keep it that way, at least for now. Sorry.

Instead, I'm taking a sharp right turn and reviewing a horror movie. Well, horror with sci-fi elements. I've been a fan of director Anthony Scott Burns' music and oeuvre of short films for a long time. Burns takes a lot of inspiration from the oft-vaunted horror greats - a fact that he makes sure to mention on social media - but also manages to put his own unique spin on things. His second entry into feature films² is his take on one of the classic thematic staples: dreams. As Burns says...³

Dreams are highly intriguing. It’s where we work out our issues, who we are, what we fear.

We all have dreams, but Come True's main character, 18-year-old Sarah (Julia Sarah Stone) has rather horrifying ones, constantly waking up in the middle of the night. This is exacerbated by an unspecified feud with her mother,⁴ forcing her to sleep in parks, classrooms, and playgrounds. When she sees the notice for a sleep study, it seems like it is just what she needs. She'll have somewhere to sleep, and all she'll have to do is ask a few questions. Well, that's what it seems like at least.

It's an enticing premise, and Burns knows how to make the opening acts of the film compelling. Although he is rather light on the plot detail - fair enough, given its unimportance - you still end up keenly sympathising with Sarah's situation. In a way, this choice is an ominous sign of things to come later in the film. In horror, there are always clues to problems lurking around the corner, and this is no exception.

Unfortunately, the nightmare sequences aren't very interesting. Although they can be legitimately frightening and suspenseful at times, too often they are overlong and of increasingly distant relevance to the film's plot - that is, until the very end, where they bounce back into relevance like a boomerang. Until then, they are some of the least interesting aspects of the film. The same can be said about some of the non-oneiric scenes: often you see Burns leave the camera rolling a little bit too long.

Nevertheless, Burns manages to set the film's tone with gusto. The dream-like atmosphere is complemented by long, partially-lit hallways, churning rows of cathode-ray monitors and control panels, and ominously lit scientists monitoring our protagonist. Apparently, Burns himself did the VFX in addition to the cinematography and direction, but were I not informed of that, I wouldn't have noticed a thing. Backing the score is the appropriately ethereal sound of synth-pop duo Electric Youth, working alongside solo artist Pilotpriest (aka Anthony Scott Burns as well). It's great stuff, and their reprise of "Modern Fears" stands out in particular. All these elements unite to comprise a somewhat disconnected and dreamy take on the 80s retro sci-fi vibe du jour, clearly inspired by films such as Alien and Altered States. However, Burns pulls it off exceedingly well - particularly impressive given his name is on the credits more times than in a Hideo Kojima game.

As the film progresses, things start to go a little more pear-shaped. The chief researcher is an appropriately wisened old guy, but a particular nerdy young scientist, Jeremy (Landon Liboiron) takes a perverse interest in Sarah, breaking rules and scientific ethics for her. Through him, we discover that the study is investigating the technology to peer into dreams, and appropriately unsettling things are starting to occur. At first, Jeremy's role is an excellent subversion of misogynistic writing, but a certain later scene feels voyeuristic and seems to reinforce those same tired old tropes. In the second half of the film, he shows up much more prominently. Again, this is a hint that Burns has left about what's coming, and I'm talking about the film's quality as well...

The last portion of the film - i.e. the final one or two acts,⁵ is easily the worst half, and I don't say that lightly. Progressively, the plot gets choppier and more thematically dissonant. The pacing gets a lot worse, and the story seems to lead nowhere. Certain details stretch plausibility, and characters vanish from the film. Some of this can be explained by a detail later in the film, but given the viewer doesn't know that yet, it just seems like bad writing. Although I'm not big on the cruciality of screenwriting, this quote³ from Burns explains a lot:

For me, making movies is more about resting on emotion than a perfect screenplay.

This is all of in service of an ending which feels both unrewarding and cliché. It's very controversial online, and though I personally didn't like it, it's at least interesting. Ideally, I'd create something new from whole cloth, but I'd at least change the way which the final twist is revealed, which reads like an internet meme. I wouldn't be surprised if Burns was inspired by an insipid Reddit joke; if he was, props to him for at least making a good three-quarters of a film out of it.

Still, despite the disappointing conclusion, Burns shows a lot of potential, reminding me why I liked his previous work. His use of atmosphere and tone is marvellous, and given the mixed opinions online, you might even like the ending. It's a movie of highs and lows, one that's worth watching despite its flaws. No matter what happens, I'd like to see what he creates next.⁶

3.83 out of 5 Novov Affirmation Points

1
I still have a list of around 10 ideas for posts that I tell myself I'll get around to eventually... or so I tell myself.
2
Although Burns had previously directed Our House, he feels that the final result didn't comport with his creative vision. Again, this is something which he's not afraid to share.
3
and 3b Come True Sees Straight Into Your Nightmares
4
Burns is somewhat light on the narrative, a detail which I'll touch on more later.
5
All of the acts are names after Jungian psychological concepts, which also feature heavily in the film. This feels a bit tired, and although most viewers wouldn't notice or care, outdated to me given the discrediting of much of Jung's ideas.
6
Hopefully he doesn't promote Joe Rogan again though.

Confessions

2021-02-14T00:00:00+12:00

In the later 1800s, the confession album was a popular fixture in British culture. The name had nothing to do with people's deepest, darkest secrets, though the "confessions" within were of a somewhat personal and revealing nature. It gained prominence for about fifty years, before falling (well, mostly) out of fashion.

Like so many cultural elements of years bygone, today the confession album has fallen out largely out of usage. It only really survives in two forms: the Proust Questionnaire used for interviews with the famous and distinguished, and in the Netherlands and Germany, books for little kids.

But I see no reason for it to stay that way - self-reflection is a quality just as valuable in adults as well, and celebrities are in the greater scheme of things no more important than the common man. Plus, it's a great way of discovering what kind of person someone is - or at least what kind of person the want to be or think they are.

I've taken the liberty of assembling my own list of questions here, with my answers.¹ Feel free to use it, so long as you provide attribution.

Question	Answer
Favourite virtue	Selflessness, honesty
Chief purpose in life	To make the world a better place, to enjoy life, to create
Greatest challenge in life	To define oneself
Personal idea of happiness	A nice book next to a fireplace; lack of worries
Personal idea of misery	Losing your sense of self
Vice you excuse most	Pride
Vice you hate most	Selfishness, dishonesty
Principal personal vice	Pride
Principal aversion	Excess
Best test of character	How someone treats those in need, or that society looks down upon²
Favourite visual artist	Albrecht Durer
Favourite medium of art	Illustration, 2D animation, electronic music
Favourite hero³	Stanislav Petrov
Favourite colour	Green
Favourite food	Anything sweet, sausage rolls
Favourite flower	Pohutukawa, hibiscus
Favourite ice cream flavour	Cookies and cream
Favourite potato chip flavour	Chicken (reasonably common in New Zealand)
Favourite motto	Lucem porta in tenebris, John 8:32⁴
Favourite academic discipline	Psychology, computer science, history
Favourite mammal	Cat
Dream home	A wooden hut in the woods, with nobody else around for miles
Trolley problem⁵	Pull the lever
Cat or dog person	Cat, but I like both
Weirdness or blandness	Weirdness

1
Based partially on the Proust Questionnaire, partially on one Karl Marx answered, and a few questions of my own.
2
Of course, excluding people who have done legitimately done horrible things, like serial killers. You could argue that morals are societal, but that's beyond the scope of this.
3
This can be either real or fictional - or both.
4
I'm not a Christian; I just like the quote
5
https://en.wikipedia.org/wiki/Trolley_problem

Twenty Years

2021-01-15T00:00:00+12:00

Twenty years ago, online encyclopedia Wikipedia was born with surprisingly little fanfare. Starting as an offshoot of the more conventional expert-contributor website Nupedia, it was conceived as little more than a flash-in-the-pan experiment. Nobody would have predicted then that it would turn into one of the web's most essential reference works, a veritable repository of information both informative and interesting - but occasionally inaccurate. ^{[citation needed]}

And although it has problems with power-tripping admins and over-zealous editors, I'm happy that it's there. The community is a testament to the power of the common man without the all too frequent handicap represented by the profit motive, and I hope it stays that way for many years to come. Here's to twenty more!

I've been editing on Wikipedia for a much measlier six years, and have been an active editor for about three, first as User:Axisixa and now as User:Mir Novov. Although most of my changes¹ have been spelling corrections there and adding citations here - typical for an Wikipedia editor - I have got to create a few articles as well:²

ToaruOS - an hobby operating system. Not bad, states the facts but little else, partially due to lack of sources.
Simon Stålenhag - an illustrator focusing on retrofuturistic artwork. Appears in my Art I like page, so this is partially out of personal bias, though I've made sure to make it neutral, as is standard Wikipedia practice. Melds together his personal life and artwork into one section, which is a bad decision.
OneShot - an metafictional video game. My favourite out of all the articles I helped create; although it could be improved some more, this is largely due to improper sourcing and bad writing skills.
IAmA - a content split from the Reddit article, in particular, the section on its I Am A.../Ask Me Anything subreddit. The content was largely written by others, and it needed to go since it was getting unwieldy. Could probably be transmuted into a more general "ask me anything" article, as the format is very popular outside of Reddit.

More than any donations,³ Wikipedia needs more editors. Maybe you could add information definitions to Wiktionary or free media to Commons or Wikisource if that's more your jam, but unfortunately, they have a far smaller reach. Ignoring that, I found that the official introduction helped me quite a bit when I started.

Even though I started using the web from a young age, I'm still amazed by the stuff that Wikipedia offers - check out my linkroll for some cool things out there. If you decide to become an editor, you'd be contributing to an ever-growing mass of digital information accessible to anyone in the world (with internet). I know it sounds quite cheesy, but I find that quite powerful. Knowledge deserves to be free.

1
Around 1100 in total, which is actually pretty small for an active editor of my vintage.
2
Note that you don't "own" Wikipedia articles that you create. In accord with the wiki ethos, all articles are released into the ether as a public good free for anyone to modify.
3
Cup of coffee etc etc. The Internet Archive needs your money more.

Gone in a Flash

2021-01-02T00:00:00+12:00

The notice on Adobe's website.

On 1 January 2021, Adobe Flash was discontinued. In fact, Adobe went so far as to say that:

Adobe strongly recommends all users immediately uninstall Flash Player to help protect their systems.

If you've reading this, you should do the same - Flash has more holes than a block of Swiss cheese. I already uninstalled Flash with the advent of Safari 14 - which doesn't support it. This has been a long time coming.

Flash, although initially a simple tool for animations, soon had grown into a more complex one supplementing every facet of web design. This came with consequences: a bevy of security issues, high usage requirements, and frequent crashes for any system that dared run it. A crowd of naysayers quickly developed around the technology, especially as open standards like HTML, JavaScript, and CSS became more advanced.

Chief among them was Apple's polarising and sometimes problematic CEO Steve Jobs, who decided to exclude Flash from the iPhone. In his manifesto Thoughts on Flash, he listed his problems with it. It wouldn't run quickly on the power-efficient iPhone OS (now iOS). It was proprietary. It was unreliable. And it was insecure.¹

At the time, his piece received both support and strong criticism. Many viewed the Flash-less iPhone as handicapped, and Apple as wanting to stifle innovation. But the fact that Flash never took hold on the rival Android operating system proved its critics right. And with the corporate mothership now behind the rising sentiment, Flash begun to fall.

According to the internet consensus, Flash is a nostalgic part of the web that was mercilessly snuffed out. I too have plenty of nostalgia for the software: I grew up using it to play weird online games, interact with stuff, and... design kitchen layouts. Yes, the last one is true.² I'm still convinced that the web is better off without it though. In addition to its many intractable problems, it's basically one company's toehold into the open web. Great emulation software like Ruffle and swf2js exists to carry its torch.

Nevertheless, I see where its supporters are coming from. Flash represents a time where the web was free for all. When everyone had their own site instead of being funnelled through mega-corporations. When netizens were more than commodities. When going online elicited wonder instead of frustration and alienation. But Flash just happened to die at an ominous time. And although my early web experience was more satisfying, in some ways it was never more than an ideal - remember AOL?

The Flash design tools were also great for quick content creation.³ The art of creating an early HTML page or spinning up an SWF has not been quite replicated - although there are projects out there trying to do it. Web design is now inaccessible to the beginner, an impenetrable stack composed of a million different technologies.

And although Flash is gone, what replaced it has issues in itself. The HTML/CSS/JS stack has become what it sought to destroy. Although ostensibly free, it is controlled by one company in practice: Google has dominance over both Chrome and search to such a degree that a newcomer couldn't hope to compete.⁴

1
To be fair, Jobs probably had additional ulterior motives in that Flash was competition to the App Store.
2
As a kid, I used to spend hours on the websites of cabinet makers and car manufacturers designing the ideal versions of their products. They get you while you're young.
3
Or so I'm told.
4
Think of the last time there's been innovation in the web search arena. Google's monopoly means there's no incentive, and their control of search essentially means they gatekeep the web.