Cats, dogs, and birbs (according to my phone)

I’ve never really used iOS’s automatic thing-detection for photo categories before, but I was looking for a specific picture of a dog from my ~8 years worth of photos, so I gave it a shot.

The 231 photos my phone thinks are of cats include:

The 214 photos my phone thinks are of dogs include:

The 76 photos my phone thinks are of birds include:

NIRB, Birb don’t want nirb scirbs a scirb is a birb that can’t get nirb lirb from birb!


On the dot org situation (external)

In case anyone reading this isn’t up to speed, the .org Top-Level Domain (TLD) is apparently being sold to a private equity firm. The post link goes out to a good summary on the Electronic Frontier Foundation’s site. This is bad, and it should be fairly obvious why it’s bad, but beyond that… the whole thing really just feels like one more large step in the inevitable decline of the internet as we know it. I’ve been expecting this to happen at any time, except with like… a novelty TLD. Like, Donuts gets tired of owning the .exposed TLD and sells it off and now everyone with a domain under that TLD has doubled rates. I didn’t see it coming (yet) with one of the Big Ones.

Is it a huge stretch to think that ICANN could, in so many decades, ceases to function or shift to a profit-driven model? There’s a sense of stability with a .com domain, but is it more fragile than we think? What if your email is tied to a domain you can no longer afford; how many services tie your identity so strongly to your email that it’s difficult or impossible to change it? Thinking in terms of decades is a bit absurd; there will be sea changes in the internet through that time. I just worry that most of those changes will be for the worse, that independence and openness will continue to be threatened, and that archival gaps will continue to increase.


Garfield Kart: Furious Racing is out, but whatever

Well, Garfield Kart: Furious Racing officially lands in the U.S. today, which means a review is in order. Not of that game, of course, but of Garfield GO – Paws, Inc.’s 2017 response to the similarly-named and certainly better-known creation by The Pokémon Company. Much like Pokémon Go, you play on a map, based on your actual location, tapping things to interact with them. Also like Pokémon Go, you can play in an AR-style mode where the objects you interact with are superimposed on camera footage of the real world around you, or you can disable this to play on static backgrounds. In AR mode, you have to rotate yourself around to find things and aim very carefully, it’s a frustrating experience just for the sake of seeing a Garf floating above your sad desk. I never enjoyed playing Pokémon Go this way either, personally.

Like so many Garf games, Garfield GO feels like a shell of a game with a half-hearted Garf theme slapped on. Even with my limited knowledge of Pokémon lore1, I knew that Pokémon Go made sense: you found cute monsters out in the wild and trapped them in tiny balls. While there’s a battle element to it and all, a core part of the Pokémon Go experience was just finding all of these different creatures and watching them evolve. The Garf imitation, on the other hand… involves you throwing food into Garf’s bowl. One of four types of food (lasagna, pizza, donut, cake); one of one type of Garf.

So if you’re not collecting different bizarro Garfs (which would have been 100% more rad in every way, tbh), what exactly is the point? Well, after you catch feed a Garf, he disappears in a cloud of smoke before appearing next to a treasure chest, fidgeting and pointing at it as though it contains the directions for defusing a bomb that’s strapped to his chest. It does not, of course; it contains coins, hats, comics, and trinkets. Which I guess I have to dive into now.

First let’s backtrack to Pokéballs food. Food is what you throw at Garf, and I already mentioned the whopping four varieties of food in the game. Donuts are unlimited, whereas the others are precious inventory items gained by spinning a wheel of food and playing minigames at the gym circus2. Foods that Garf likes more3 have an increased chance of spawning chests with better treasure in them. You can also bake a piece of food for free at any given time in your oven.

Coins are boring, they’re for buying stuff when you don’t want to find and/or wait for it. Coins can also be bought with real money, because of course they can. Real money can also be spent to increase your range on the map from 100 ft. to a whole mile, this costs $3 for an hour. Several of the hats in the game are also exclusively purchased with real money, meaning a completionist will spend $16 to acquire all of Garf’s hats. Anyway let’s talk about hats.

Hats are… hats… that Garf… wears. This is the only way you can customize Garf, and doing so has no effect aside from the obvious visual. There are hats with various countries’ flags on them, two colors of pirate hat, three fedoras if you want to make Garf look like three shades of douchebag, and a head-mounted Pooky, among others. Outside of this game, I don’t know of Garf having any particular affinity for hats, but in Garfield GO, hats are his JAM.

Trinkets! They’re inefficient coins. Things like dog collars, bowties, newspapers, baseballs. You trade them in predetermined sets for a handful of coins; for example two donut boxes, one fishing lure, and four empty pizza boxes nets you 82 coins.

Comics are the only thing that provide any sort of motivation to continue playing the game, they are the only meaningful ‘collection’ element. They come up fairly rarely, and you get a single panel at a time. They don’t seem to come in any particular order, so potentially collecting an entire three-panel strip will take some doing. I don’t think it’s a particularly worthwhile catch ‘em all collection reward, but it’s the best thing this game has.

So, Garfield GO is effectively a game where you throw food for the chance to see Garf in a hat (you can actually see him in any of the hats from the hat screen, even hats you don’t own) or to read Garfield strips that are all readily available at GoComics or garfield.com. Apparently, at one point, you could potentially win real-world prizes, but those don’t exist anymore and I’m not going to research what they were. Pokémon Go is engaging, it draws you in to the world around you while also drawing you in to the world of Pokémon. Garfield GO doesn’t have the landmark-esque quality that Pokéstops do; its attachment to the GPS feels far more superficial. Nor does Garfield GO feel particularly attached to the Garfield universe; all one would take away from this game is that Garf is a hungry cat who dons hats, likes to visit the circus, and can vanish in a cloud of smoke. It’s absurd.

The game hasn’t been updated to support iPhone X-sized screens, and as mentioned, the ‘Puzzle pieces’ which would potentially lead to real-world prizes are no more. I doubt there’s any more content coming for this game, whatever that would entail. I wouldn’t be surprised if it dropped off of app stores within the next year or so. But if it sticks around, it doesn’t need to. Beyond brief curiosity, there’s really not much value in this game. It seems to exist simply because it can4. I guess check out Garfield Kart: Furious Racing instead, it can only be better than this.


  1. Prior to playing Pokémon Go, Pokémon Snap was the only game in the franchise that I had any experience with. But! I’m currently playing and enjoying Pokémon Shield quite a bit and will likely be checking out some of the older games. My experience with Shield confirms that Pokémon Go… makes a lot of sense. ↩︎
  2. According to the in-game help, these are actually Italian bistros? But they’re definitely big tops. I don’t know. ↩︎
  3. Assuming this game’s concept of Garf’s food preferences is canon (lol), he likes donuts the least, followed by pizza, followed by cake, and obviously likes lasagna the most. ↩︎
  4. And, I mean, to extract hat money out of children. ↩︎

IDBiG: Implicitly-Dimensioned Binary Grid

A while back, I got an idea stuck in my head. If one wanted to, say, scratch a series of tick-marks into small bits of metal to serialize and identify them, how would one do this? Small is key here; easily printing decimal numbers may not be possible, and something like a binary number may be limited in length. The obvious solution, to me, is a flexible, two-dimensional binary grid. But what happens when you make a mark like this:

Five hand-drawn tick-marks, spaced unevenly.

Expecting a human to perfectly line up a series of marks is rather unreasonable. This example is probably 3x2, but that last column is far enough away from the second that… maybe there’s an empty column in between? We have plenty of numbering systems that are wasteful, they don’t actually represent as many numbers as the most efficient use of that radix would allow (binary-coded decimal is probably the most common example). Why not waste bits to remove ambiguity? Put in place a requirement that every row and every column contain at least one tick. Under this system, we know that the above grid is 3x2. Even if we push the third column far, far away, we only have ticks in three columns and we only have ticks in two rows:

…and it remains a 3x2 grid for our purposes. There are other solutions – explicitly indicate the dimensions somewhere near the grid, or use two different sorts of markings to indicate 1/0 states. But I was interested in my original idea, and it proved to be a bit of a white whale for me as I thought about it on-and-off over the past month. For illustrative purposes, I will use 0s and 1s from this point forward in this post.

The first step was figuring out just how many values could be encoded in a given grid size. If, for a 3x2 grid, we allowed all combinations of 0s and 1s, we’d have 64 possible values. But we’ve added a pretty strong restriction:

000
001
011
010
011
100
Invalid Invalid Valid

Through a combination of Excel and Vim, I manually generated valid state counts for 2x2, 3x2, 3x3, and 4x2 (7, 25, 265, 79 respectively). A quick trip to the OEIS brought up a few sequences, including A183109, “Triangle read by rows: T(n,m) = number of n X m binary matrices with no zero rows or columns (n >= 1, 1 <= m <= n).” Read out as a triangle, we can glean the total number of valid states for a grid of any size. Once I knew what I was looking for, this was a pretty simple part of the puzzle to crack. Could I, however, devise a system that would make this human-readable and human-generable1?

This proved much trickier, and while I’m satisfied with my conclusion so far, it may be possible to improve upon. I also will only be speaking in terms of 3x2 from this point forward, as I have not put any effort into generalizing the process yet2. Coming up with something even remotely practical has frustrated me to all hell over the past month. There are things that are definitely known: mainly that we have at maximum six and at minimum 3 ticks. There are different numbers of possibilities for each of these: grids with 3 and 5 ticks have 6 valid states each, 4 ticks has 12, and 6 ticks has only 1. Let’s define some positions:

abc
def

Initially, it seemed like position a was a good place to start, and that if a was alone row- and column-wise, than e and f have to be set. This felt like a good state for 1. Likewise, if b is alone row- and column-wise, d and f need to be set, which we can call 2.

1 2 3 4 5 6
100
011
010
101
001
110
011
100
101
010
110
001

…but now what? With one isolated tick, it’s easy to identify it as a key and use its position to determine our value. But how do we make 7 just as easy? We can’t simply repeat a similar process if both a and b are set. Among other problems, we’ve already used one of those states for 6. This became a recurring issue as I experimented with methods – I would hit a point where a value collided with an earlier value, and I’d have to try to add rules to avoid such collisions. Adding rules quickly made the process too difficult to mentally sort out. I set the concept aside for a week or so.

Then I dreamt about a fantastical mathematical machine. A giant orb with pronged arms, very similar to the mechanical binary-coded arms of an IBM Selectric. These, however, were notched in ternary. The orb interfaced with the world around it in an incredible display of cogwork, effortlessly decoding values and spitting out numbers. I got to thinking about the problem again.

Whereas before I had largely been thinking about ways to count, to indicate adding and carrying a value through multiple passes, I began to think about different ways of composing values. I thought about pairing up neighboring elements to make 7 2-bit states. I thought about powers of two. I realized I likely needed subtractive positions since there are a minimum of three ticks. Then it occurred to me that I needed to invert the grid first, use the empty (0) values as indicators. There can’t be only one tick, but there can be only one empty spot. This makes 1 a possible value without any subtractive elements. Mapping things out this way, I thought about diagonally bouncing 1-3 and 5-7 (1+2+3+5+6+7=24, so that felt plausible). I thought about powers of two, again, with 1, 2, 2, 4, 8, and 16. I somehow landed on 1, 1, 3, 6, 6, 11 and 1, 1, 2, 3, 6, 11 as magical, hopeful sequences.

None of these worked. Two things would happen: I would run into duplicates, and I would get stuck at a value much lower than 24. As an example:

Decoding key
(Using 0s)
4 Also 4 9 is invalid
1 3 11
2 6 1
001
111
101
110
010
010

What I ultimately stumbled upon came of the defining rule of positioning, whether we’re talking about binary, ternary, decimal, or any other radix. In a four-bit binary number, the positions are 8 4 2 1. Each position represents the lowest number that we can’t yet compose. 1+2=3, so our next position must be 4. Our grid works the same way, the rules just aren’t as simple. Again, using the zeroes or empty spaces as our ‘bits’ instead of the ones or ticks, we end up with this decoding pattern:

11711
236

This is not perfect. It’s obvious that the only way to construct 20 is 17+3, which is an invalid state. So, if incremented values are important, this maxes out at 19. There are, however, no duplicates, which means we do still have five more valid values (since we’re using the empty states as indicators, a full grid of ones represents our first value, zero). We end up with 0-19, 23-25, 28, and 30.

0 1 2 3 4 5 6 7 8 9
0 111
111
011
111
111
011
111
010
011
010
111
001
111
110
011
110
111
010
111
100
1 011
011
110
111
010
111
110
011
110
010
010
101
110
001
101
111
001
111
101
011
2 101
110
001
110
101
010
100
111
3 100
011

I’m fairly happy with these results, and I think it’s the most effective solution that’s human-readable, and has a key that’s easily human-generable. Generation is basically a spiral of what we are thus unable to compose. We can’t add 1+2 in a valid state, so the next value must be 3. From here we can make 1, 2, 3, 4, 5, but we can’t make 1+5, so our next value must be 6. That row can’t be summed up, so our next value must be 11. And we can’t add 11+6, so our final value must be 17.

I mentioned in an earlier footnote that I have played with a 4x2 grid, which maxes out at 423 continuous values. This is intended to be the first post in a series, the next of which will hopefully have some insight as to generalizing the process. If I can figure out how to set Sentient on the problem, I wouldn’t mind seeing what it comes up with as well.


  1. The basic requirement here for human-friendliness is no memorizing. Given 24 possible states, we could just map them to 24 values and memorize that, but that… sucks and does not scale. Even memorizing the number of states for a given set of dimensions (so one could potentially work backward) seems unacceptable to me. ↩︎
  2. I have done an initial test with 4x2, which has proven as viable as 3x2. I’m not entirely sure how squares will work. ↩︎
  3. Hmm. ↩︎

Keyboards, old and new

Reading a typewriter-themed Garfield strip recently, I got to wondering whether or not my typewriter (a Brother Charger 11) even had 44 keys. It does, barely. Despite modern computer keyboards still using the same core QWERTY layout from the 1800s, things are different enough that this was a perfectly reasonable thing to be unsure of. Then I got to thinking about all of these differences, as well as the weird holdovers (QWERTY itself notwithstanding) and… here, I suppose, are just a bunch of those things that I find interesting. I guess some of it might even be informative if you haven’t used a bunch of different typewriters (or, somehow, a computer1).

Shift, and its locks

On old mechanical typewriters, Shift… shifted something. Specifically, either the entire assembly that holds the paper in place (the carriage) or the assembly that holds the typebars (the basket). In doing so, two characters could be placed on one slug, with the top half of the slug regularly hitting, and the bottom half when the page was shifted upward. Generally speaking, this meant switching from one case2 to another, though figures and punctuation don’t have a case. Shifting such keys generally led to different punctuation or other symbols, as it does today.

Shift keys traditionally were unlabeled, as was the Shift Lock. This is the forerunner of our Caps Lock, which has a different name for a very good reason. Shift Lock also physically did what it’s name described – it locked the mechanism in that shifted position. The typewriter had no means to unlock it for specific keys, so every key would strike the shifted part of its slug. On a modern computer, this isn’t true – Caps Lock does what its name implies as well, shifting only letters into their capitalized forms.

It’s worth noting that Caps Lock is far less important on a modern computer than Shift Lock was on a manual typewriter3. Holding Shift down on a computer keyboard is trivial, holding it down on a manual typewriter meant holding that mechanism up (with your pinky!). It was a heavy key.

Commas and periods

I mentioned that, on a manual typewriter, punctuation keys generally shifted to different symbols. Keeping in mind that every key is shifted when Shift Lock is engaged, it was generally a good idea to avoid this on the most common bits of punctuation – the comma and the period. Both halves of the period and comma slugs on manual typewriters typically have the same piece of punctuation. Unlike letter keys, the print on the key itself reflects this, showing two periods or commas. Specialised models and models for non-English locales tend to be exceptions, where the need for additional characters outweighed this convenience.

Greater-than and less-than were typically not included on manual nor electric typewriters. Some specialized exceptions exist, like terminal versions of the IBM Selectric meant for entering APL and ALGOL. The Diablo/Xerox Hyterm, an early daisy-wheel terminal, included these characters at their current positions. Despite that, this positioning wasn’t any sort of a standard, nor were the characters even guaranteed to be included throughout the electronic typewriter era. In fact, simply due to convention, even some dot-matrix typewriters like my Brother EP43 kept shifted commas and periods as commas and periods.

Backspace

Much like Shift, Backspace used to describe the thing that it physically did. It moved the carriage back one space. It didn’t delete anything, because that was not possible. If the user erred, they would simply backspace over it and overstrike the error with a bunch of Xs or whatnot. If neatness was important, they would backspace over the mistake, strike the same character through a sheet of correction paper or film, backspace one more time, and finally strike the replacement character. This process was the same when correction material became integrated into the ribbon.

The (electric) IBM Correcting Selectric II was, as far as I know, the first to introduce a correction key. Being an electric and not electronic typewriter, the typewriter had no memory of what was to be struck over the correction ribbon. The key () cut out parts of the process, but it still wasn’t analogous to what we, as computer users, think of as backspace. Later electronic typewriters with memory would introduce a correction key akin to our Backspace, but it did not replace Backspace, generally placed to the right of the space bar. We’re left with not one, but two keys whose names make little sense – Backspace, being a key that deletes things and does not simply move a space to the back, would be better named Delete; by extension, what we call Delete is highly unintuitive4.

Ones and exclamation points

So, on many manual typewriters, these keys simply don’t exist. I once had to explain to a confused thrift shopper that the one key was not, in fact, missing but that its omission was by design. Adding more type bars to the basket increased… a lot of things. Cost, likelihood to jam, overall complexity. And when your lowercase el looks like a one anyway… why include it? When you can type a period, backspace over it and strike a single quotation mark… why do you need an exclamation point?

A key providing an unshifted one and a shifted exclamation point became common in later and higher-end models, but even my Charger 11 from the ‘80s omits it. And these two characters sharing a key is a convention that remains today, simply because they were two universally-omitted characters at one point in time.

Enter, or CR/LF

Folks who have to deal with data interchange are likely well aware that carriage return and line feed are two very different things, a holdover from typewriters (and later, terminals). When one approached the end of a line, two things had to happen – the carriage had to return to the leftmost position, and it had to rotate the platen one (or more) lines ahead. While integrated into one mechanical linkage, they were two separate things happening and could be performed independently. Being that they were actions mechanically manipulating the carriage and not involved with the type bars, this function was performed by a lever on the carriage and not a key.

Electric typewriters changed this, and Return became common. Since motors were now doing the work, marketing tactics meant this key was often called Power Return. Some kept the entire Carriage Return name. Though quite distant from where the carriage return lever would be on a manual typewriter, this key started its life in 1925 in the position it still sits today.

Characters found, and characters lost

Aside from the absence of one and the exclamation point, non-alphanumerical symbols tend to differ greatly from the manual typewriter era until now. These weren’t quite so standardized as the basic QWERTY layout, but there were some definite trends. Use in creating sales slips and the like meant that ½, ¼, and ¢ were ubiquitous, with other fractions common on more specialized typewriters. Oddly, plus and equals signs were often omitted. Parentheses were typically the only form of bracketing present. Models for non-English locales would introduce isolated diacritic marks, meant to overstrike the letters they combined with.

To wrap this up…

We’ve kept the name Shift, despite nothing shifting. We’ve kept the concept of Shift Lock, but updated it for the conveniences allowed by the digital realm. Both keys kept their respective positions, but are now larger and labeled. Backspace got to keep its name as well, also despite being fully detached from its original (and literal) meaning. We can type ones and exclamation points now, but have to work a bit harder to make fractions. When we want to insert a new line in a document, we don’t smack the left side of our screen. A shifted comma is no longer comma, and other shifted punctuation has moved around and settled into standard placement.

I use my Charger 11 fairly regularly, but I’ve used a computer for hours daily for the past… two decades? There’s a certain uncanniness that comes of the occasional quirky missteps despite being largely able to touch-type.


  1. I meant this as a joke at first, but I do feel like it’s unlikely, yet entirely possible that we’ve reached a point where the person reading this may never have used a computer or a physical keyboard. ↩︎
  2. ‘Case’ also being a term taken from the physical world, that of literal cases full of movable type in letterpress printing. ↩︎
  3. I always remap Caps Lock to Ctrl. Germany’s keyboard standard makes Caps Lock optional, preferring the key be replaced with Alt Gr. ↩︎
  4. Apple has historically gotten this ‘more right’, but I certainly wouldn’t call it standard. ↩︎