One of the biggest features of the SS and DX series’ is the idea that decisions have consequences. This is rarer than you might think. Skyrim, for example, has decisions, and those decisions have consequences – do I kill the turncoat fence as part of the Thieves’ Guild questline? Do I destroy the Dark Brotherhood, or join them and kill the Emperor? – but the consequences are all small fry. If I kill the fence, whatever: maxing out Speech turns every damn merchant into a fence. If I kill the Emperor, fine – it doesn’t stop me from completing the Imperial Legion storyline, and the only change to the game as a whole is a single line of dialogue. No action leads you into a situation that can’t be escaped from.

This is sort of a problem; I love Skyrim, but it’s not for its decision trees – it’s because it’s a really big sandbox.¹ I do not feel that the failures or successes of the Dragonborn are my own, and I do not identify with them. This is partly because of the design choices (the Dragonborn is the Dragonborn. Before that you played the Hero of Kvatch. At no point did you play ‘Oliver’) but also because at no point do I have real control over the game. It’s a good game, but it’s not a great game.

For a great game, you need decisions with real consequences: you need the impact to be far enough down the line that by the time you get there it’s too late to do anything about it. You need the player to be going “oh, fuck, I should’ve done X“. The DX games do this very well; everything is fixed once it has been decided. If you’ve got a pair of bots opening up at you and you decided to put your points into a cloak that hides you from biologicals, well, fuck you.

This works for two reasons: first, as stated, consequences are far enough in the future that making a different decision is very, very hard (or impossible). The past is immutable. Second, however, the decisions are obviously decisions. To draw on the example above: when immutably assigning augmentation points, I was told “Oliver, you can have either A or B. A will hide you from biological enemies. B will hide you from mechanical enemies. Choose wisely”. This is a necessary element of the “oh fuck” moment; the knowledge that you could have avoided the shitty situation you find yourself in. It creates a large amount of replayability because, on completion, the user has an incentive/opportunity to restart and handle things differently.

However, there is another kind of decision-making; subtle decision-making, that leads to subtle replayability. This is something DX handled really, really well (I happen to think the System Shock games did not, or, more accurately, did not bother trying). The example I used above was one where the interface prompts you with ‘this is a decision’, but there are many where it doesn’t.

So: example time, yet again. Around halfway through the game you’re tasked with infiltrating the Brooklyn Naval Shipyard, where a cargo vessel filled with vats of virus is being stored.² Now: you can totally just break in. Takes a bit of effort, but you can do it. This is not, however, your only option.

Earlier in the game you’re confronted with a pimp beating his hooker, Sandra (yeah, it’s a bit dark. It’s a fucking dystopia. Or as we call it, New York City). No plausible relationship with the Naval Shipyard; hell, at that point, you don’t even know the Shipyard exists. No plausible consequence of what you do – she’s nothing more than a particularly unlucky hooker in a particularly unlucky city. You can save her, or you can let her die. Fine.

Except….if you let her live, suddenly you don’t have to break into the Shipyard. Because that unlucky hooker went to high school with a guy who can get you inside, no questions asked, without any fighting. And suddenly Sandra is Important. Things like this are littered throughout the entire first game – there is no one way of doing anything – but they don’t make themselves immediately known.

Skyrim fails at decisions because it’s got obvious decisions with small consequences. DX wins because it’s got obvious decisions with big, immutable consequences. This enables replayability to resolve “oh, fuck” moments But DX also has a third kind of decision; subtle, with small (and not-so-small) consequences. They do not incentivise by way of resolving “oh, fuck” moments; they incentivise because once you’ve discovered one, maybe in your second playthrough to resolve an “oh fuck” moment, you want to find what else is out there. The first DX game handled this really, really well, as did the third.

So while a good game, like Skyrim, doesn’t need to have any consequential decisions, and a great game only needs to have consequential ones, a really fucking great game has those going hand in hand with subtlety and nuance. With things that have consequences without ever appearing to be decisions at all.

1. into which I can put my own stories, which is why I’ve logged 566 hours. I should really play less.
2. a vessel of vats of virii. Very verbose.

May’s basic issue is that some judges think they know better than Parliament, they’re not enforcing her guidance, and this cannot stand. What would happen if we lived in a world where judges could trump Parliament on occasion?

It wouldn’t amaze me if some judges felt they were better than Parliament, but there’s no real evidence that this is the case – May’s argument is that one judge felt comfortable overruling the Immigration Rules because they’d been subject to poor Parliamentary scrutiny. This necessitates a brief recap of the legal situation with the rules changes she’s complaining about.

So. Updated Immigration Rules were laid before the House of Commons by May and her subordinates on 13 June 2012. They’re secondary legislation – a form of statutory instrument for procedural purposes, if I recall – which is why it’s “laid before” instead of “submitted for the approval of”. And the way that Parliament approves such legislation is…..er, well, most of the time it doesn’t, actually.

Statutory Instruments are normally approved through a “negative resolution” process; if people don’t object loudly enough in 40 days, it’s passed and put into force. Not a particularly democratic process, and not a particularly Parliamentary form of legislation, which is the entire point: it exists to make small rule changes to the working of overarching, primary legislation.

The fact that Statutory Instruments are not valid indicators of Parliament’s will (passed by a single House, not both, and usually not needing actual approval to be classed as ‘passed’ anyway) has long been recognised, both by the government and the courts. One of the ways this has been recognised is that, oh yes! Judges can overrule, override and simply throw out statutory instruments and other forms of secondary legislation. Because they’re not subject to enough Parliamentary scrutiny to be Parliamentary.

So, really, what May is complaining about is the way that government and the judiciary has worked since SIs became a thing. This is something that people warned would happen – people with actual qualifications – and yet she still loudly sits there trumpeting her utter ignorance of policy, procedure and fact. I wouldn’t be amazed if judges felt that they were better than MPs; every time May opens her mouth in front of a reporter she provides supporting evidence for this argument. But really, what she’s complaining about is nothing new. If she wants to class SIs as Parliamentary legislation, then the answer to “what would happen if people thought it was okay to overrule Parliament’s wishes?” is – nothing. At all. Because we’re living in a world where that’s the case.

Objects are the mindkiller.

I absolutely loathe having to assign a function output or value to an ObjectName. Really, really hate it, not in a this-is-non-optimal-way, but in a vicious, angry way. Whenever I write code these days, I try to write it in such a fashion as to use the smallest possible number of object names, where “smallest possible” is defined as “at most, assign object names only to output you plan on using multiple times”. There are a couple of reasons for this.

Objects shadow

If I write:

A <- c(“twerp”)

A <- c(“derp”)

Then what I’ve done is assigned to ObjectName “A” the value “twerp”, and then immediately overwritten it with “derp”. This is fairly normal, but it’s also a potential problem: if you end up accidentally giving two different things the same rational.objectname.df, you’ve just overwritten the first with the second. Every object you create reduces the list of rational objectnames you can use for every other object you need to create. By avoiding the creation of objects except where strictly necessary, you reduce this risk.

Objects persist

When you assign something to an ObjectName in R, it persists, in the sense that it is stored in the RAM until you run an rm() function or close the session. This is, obviously, really useful if you want to call something multiple times – but if you don’t, it’s simply going to hog RAM until you manually and ickily kill it with rm().

So, why not just use rm()? Well…the first reason is a really terrible one, and that’s “it’s unnecessary code”. It’s not code that hogs running time, but it’s code that doesn’t have to be there but is because you chose to give things names. The second reason, though, is that with R you can either remove all objects (rm(list = ls())) or specify a list of objects to remove (rm(objectblah,objectbool,objectbrah)). People rarely want to kill all objects half way through a script, which means specifying objects, which means leaving your code extra-vulnerable to name changes and/or the introduction of new objects, which means yet another thing that requires active maintenance.

So the choices are allowing objects to unnecessarily persist in RAM, killing them in a finnicky way that creates additional work in the future, or avoiding objectnames. Unnecessary persistence is not in and of itself a problem, unless you work with really big datasets…which I do. When you have 9 million elements in a single dataframe, storing 3 or 4 permutations on that makes things start to creak. If those 3 or 4 things are being stored unnecessarily: don’t do it. Some extra processing time is sometimes acceptable if the alternative is R choking and dying.

1. sorry! Another code post. I’ll be throwing up different things soon, I promise.