Skip to content

A Glossary of Game of Thrones Terms

January 6, 2015

Game of Thrones is a series of books written by George R. R. Martin. They are set in a fictional world filled with dragons, spells and walking dead. Nevertheless, to distinguish this work as fantasy, the author was compelled to use an artful lexicon of archaic words, which may confuse us modern speaking readers at first. If so, use this glossary of words you may encounter as a guide.

  • Eddard- a male name that may be abbreviated as “Ned” (just like “Edward”).
  • Milk of the poppy- an opiate-based drink to treat pain. Appears often and never abbreviated, as this world has not yet invented slang for their drugs. But if I were in Westeros, I’d surely call it “moppy.”
  • Nuncle – it means uncle, but with an inexplicable n in front.
  • Northron- northern, somehow spelled in an outdated Scottish way.
  • Pease- peas.
  • Robb- a male name, pronounced the same as “Rob.” God save us when Game of Thrones fans start naming their real children after these characters (see Eddard).
  • Ser- used to address a knight, but in the same way we might use the word “Sir.” In other words, misspelled.
  • Southron- see Northron.
  • Smallclothes- underwear. Actually an 18th century word for breeches, even though Westeros more resembles 11th century.
  • Strongwine- literally means “strong wine.”
  • Summerwine- literary tip: conjoin any adjective with wine to be swept away to a fantasy world.
  • Sweetcorn- a husked vegetable that grows in ears, with high sugar content.
  • Two and twenty- twenty-two. Ages are expressed least significant digit first because fuck knows why.

At first I thought most these words were made-up, but most can be found in references as archaic (and all from inconsistent centuries at that). However, there’s also a strong propensity to create words by simply joining two words. But despite this, it’s important to know that you can NEVER combine the word “break” with “fast.” In Game of Thrones, despite the number of joined words, breakfast is not a word. However “break your fast” appears a shitload.

I really like the stories told in Game of Thrones, but there’s nothing like encountering an archaic word to rouse you out of the fiction and back into “why am I reading this again?” I imagine the intent is to immerse the reader in the world, but it has the opposite effect on me–it’s not fooling me into thinking I’m reading a 16th century tome, it’s just annoying me.

Increase the Size of a Linux Disk in VirtualBox

March 26, 2014

After running out of space on a VirtualBox, I searched for some instructions on how to expand the size of the drive. I found a couple of good descriptions, such as this one, and this other one, both which are very similar.

Both of these instructions conclude with you happily finding the extra space when restarting your virtual machine. For me, this was a sadder experience. Once I rebooted the machine, it still showed the same amount of space. The reason was that the storage on my VM is managed by LVM, and although the physical space was expanded, the logical volume still needed to be extended in order for the system to use it.

This HOWTO reference explains how to extend a logical volume, and I used the following steps:

$ # Extend the volume to consume all of the free physical space
$ sudo lvextend -l +100%FREE /dev/mapper/vg_agent-lv_root
$ # Resize the filesystem to the logical volume size
$ sudo resize2fs /dev/mapper/vg_agent-lv_root

Here /dev/mapper/vg_agent-lv_root was the name of the root filesystem as reported by df. I was able to run these commands on the already mounted filesystem (they worked without requiring an unmount). After running the two commands, my root filesystem joyfully showed the correct full size.

Starbase Encoding Gotcha

February 24, 2014

There’s a library for Python called Stargate that makes it easy to interact with HBase over the REST server.

While trying this library, I discovered a potential gotcha if you’re expecting to be compatible with the Java library for HBase: if you insert any data that is not already a string via Starbase, then it will be converted to a string before it is written to HBase, whereas the Java library encodes the integers as raw bytes. It’s easy to work around, you just need to be aware of it.

For example, say I have an integer value stored in a python variable; to insert it to a column called “info:myInt” for row “fromStarbase” in Starbase looks something like:

my_int_value = 12345
t = c.table('testTable')
t.insert('fromStarbase', { 'info:MyInt':my_int_value })

As the Starbase library prepares this data for submission, it calls str() on the variable my_int_value, converting it to the string "12345".

Using the Java API, the same action looks something like:

int my_int_value = 12345;
Put p = new Put(Bytes.toBytes("fromJava"));
p.add(Bytes.toBytes("info"), Bytes.toBytes("MyInt"),
    Bytes.toBytes(my_int_value));
HTableInterface table = pool.getTable("testTable");
table.put(p);

This uses the function Bytes.toBytes(int) to encode the integer value. In this case, it does not covert it to a string, but rather to an array of bytes in big-endian order.

Note that either approach is incorrect, because HBase deals in sequences of bytes, and is agnostic as to how you choose to encode data. However, by convention, I suspect the Java approach is more widely used, and therefore somewhat expected.

On the other hand, the HBase shell also converts values entered in the shell to a string, so maybe people do expect it:

put 'testTable', 'fromShell', 'info:MyInt', 12345

Doing a scan of the table from the shell we can see the difference in Java from the other two:

hbase(main):016:0> scan 'testTable'
ROW            COLUMN+CELL
 fromJava      column=info:MyInt, ts=1393306182999, value=\x00\x0009
 fromShell     column=info:MyInt, ts=1393301137823, value=12345
 fromStarbase  column=info:MyInt, ts=1393301137823, value=12345
3 row(s) in 0.0230 seconds

Converting to string does have the benefit of making it human readable from the shell. But for most data I would prefer the Java convention. To make the Starbase and Java share the same encoding for integers, encode the value before inserting it:

def encode_int(intval):
    """Encode integer as a string in big-endian order."""
    chars = [ chr((intval >> i) & 0xff) for i in range(24, -1, -8) ]
    return ''.join(chars)
 
my_int_value = encode_int(12345)
my_encoded_int_value = my_int_value
t = c.table('testTable')
t.insert('fromStarbaseEnc', { 'info:MyInt':my_encoded_int_value })

Now the value is encoded the same as the Java client:

hbase(main):017:0> scan 'testTable'
ROW               COLUMN+CELL
 fromJava         column=info:MyInt, ts=1393306182999, value=\x00\x0009
 fromShell        column=info:MyInt, ts=1393301137823, value=12345
 fromStarbase     column=info:MyInt, ts=1393301137823, value=12345
 fromStarbaseEnc  column=info:MyInt, ts=1393306195342, value=\x00\x0009
4 row(s) in 0.0250 seconds

The Java library uses similar binary encodings for longs, floats and doubles, so for completeness you need the analogous encoders in python.

Restoring the Chrome App Page as the Default.

November 25, 2013

Shortly after the previous post, which mentions that I use the App page as the default browser start page, Google rolled out a change to Chrome where a search page appears in its place instead. To reach the App page now requires selecting an item from a menu bar.

I don’t care for this extra level of indirection, but fortunately my coworker clued me in on how to restore the previous behavior. In the Chrome flag settings, found using the link chrome://flags/#enable-instant-extended-api, is an option to disable the feature called “Instant Extended API.” With this disabled, the App page returns as the default.

There’s many other flags to play with, so knowing about this page might be a good thing (or bad, depending on how many things I end up breaking by tweaking too much).

A Yahoo! Mail App for Chrome

August 12, 2013

Both Gmail and Outlook offer an “app” for Chrome from which you can open your email. Since I use Chrome with the app page as my opening/new tab page, these are handy links.


Screen Shot 2013-08-12 at 5.24.28 PM

For some reason, Yahoo!, a company with over 10,000 employees, cannot be bothered to create a Chrome app for their 250 million emails users, some of which besides me must presumably use Chrome (which has just under 20% browser market share).

Maybe this is low priority for them, but really, it takes 5 minutes. So I did it myself.

There, that’s better:


Screen Shot 2013-08-12 at 5.26.00 PM

Google’s rules don’t permit me to submit this to the Chrome store because I don’t own the yahoo.com domain, so unfortunately if you wish to install it you must do so manually. Download it from here, open the extensions page in Chrome (Menu/Settings/Extensions), then drag the file from the file finder/explorer into the extension page.

If you see Marissa or Jerry, tell them I accept cash or check.