Month: July 2016

Conlangs as passwords

Keeping our information secure is a high priority these days. We hear a lot about “two-factor authentication”, which usually boils down to “give us your mobile number so we can sell it”, but the first line of defense for most accounts remains the humble password.

The problem, as eloquently stated by XKCD #936, is that we’ve trained ourselves to create passwords that are all but impossible to remember. And the arcane rules required by some services—banks are the worst offenders—can actually serve to make passwords less secure than they otherwise could be. There are two reasons for that. One, the rules of what’s an “acceptable” password restrict the options available to us. An eight-character password where one of those characters must be a capital letter, one must be a number, and a third must be a “special” character (but not those that might interfere with the site’s code, like the semicolon) really only gives you five characters of leeway.

The obvious solution is to make passwords even longer, but that brings into play the second problem. A password like eX24!mpR is hard to remember, and that’s only eight characters. Extend that to twelve (Ty93M@tsD14k) or sixteen (AsN3P45.tVK23hU!) and you’ve created a monster. Yes, muscle memory can help here, but the easiest way to “remember” a password like that is to write it down, which defeats the whole purpose.

The XKCD comic linked above outlines a way to solve this mess. By taking a few common English words and smashing them together, we can create passwords that are easy to remember yet hard to crack by brute force. It’s ingenious, and a few sites already claim to be “XKCD-936 compliant”.

But I had a different idea. I’ve made my own languages, and I’m still making them. What if, I thought, I could use those for passwords? So I tried it, and it works. In the last year or so, I’ve created a few of these “conlang passwords”. And here’s how I did it, and how you can use the same method.

Rather than a few unrelated words, a conlang password is a translation of a simple phrase. Usually, I try to use something closely related to the function of the site. For example, my account on GOG.com is the phrase “good old games”—the site’s original name—translated into one of my older (and unpublished) conlangs. Similarly, my start page/feed reader has a passphrase that means “first page”. My password on Voat translates as “free speech”. All very easy to guess, except for the fact that you don’t know the language. Only I do, so only I can do the necessary translation.

Going this way gives you a couple of extra benefits. Case is up to you, so you could use a phrase in title case for those sites which require a capital letter. Or you can use a language like Klingon, with capital letters already in the orthography. Special characters work about the same way; add them if you need to, but in a more natural way than the line-noise style we’re used to. And since our password is a full phrase, it’s likely going to be near the upper end of the length range, making brute-forcing an impossible task. If it’s allowed, you can even add proper spacing between words, further lengthening the password and frustrating hackers. Also, if the site requires a “security question” (a misnomer if I’ve ever heard one), and it lets you use a custom one, then you never have to worry about forgetting the password, as long as you remember the language.

There are, of course, downsides to this method. Numbers are…difficult; the best option I’ve found for places that make you put one in is a kind of checksum. At the end of the password, simply put the number of letters you used. As an example, let’s say we want to use our example conlang Isian to make a password at Amazon.com. (By the way, that’s a bad idea, as information on Isian is open to all, even if no one’s really looking.) In my opinion, a good phrase to describe Amazon is “they sell everything”. In Isian, that translates to is dule lichacal. Thus, our password could be something like IsDuleLichacal. Fourteen characters, three of them capital letters. And we can take on a 14 at the end to up the strength a little more, or satisfy overly strict systems. As long as you’re consistent, memorization is less of a problem. And you don’t need to write down the password itself; just the key phrase is enough.

Now, not every language works for this. For very good reasons, passwords using Unicode characters are not recommended, even in those rare cases where they’re supported. The ideal conlang for password use is something more like Isian: no diacritics, no funky letters like ə, just basic ASCII. Letters, numbers, and a few symbols—in other words, the same set of characters that passwords can use.

The best conlangs are probably the most English-like in style. Somewhat isolating, but not too much. Relatively short words. A reasonably uncomplicated grammar, so you don’t have to sort through all the rules. Oh, and you’ll definitely need a sizable vocabulary to cover all the concepts you might want to use in your passwords. Just a grammar sketch and the Swadesh List won’t cut it.

Not everybody will want to go through the effort needed for this scheme. But, if you’ve got an extra little conlang around, one you’re not using for anything else, you might want to give it a shot. It can hardly be less secure than the sticky note on your monitor, right?

Software internals: Trees

We’ve talked quite a bit about data structures in this series, although not as much in recent entries. We’ve seen lists and arrays, two of the most important structures around, but they both have a severe limitation: they’re linear. While that’s great for a lot of data that computer programs manipulate, there comes a time when you need to represent both the data and its organization, and that calls for something more substantial.

The tree is a data structure that represents a hierarchy. Like a real tree, it has a root. It has branches and leaves. And a collection of data trees is also called a “forest”. But those similarities are a bit artificial; the terms were chosen for the analogy. What these trees do isn’t much like the natural ones. To a programmer, however, they’re far more useful.

In the abstract

A tree starts with a root. This is a data node, like one in a linked list, and it can hold one value of any type. If you’ll recall, nodes in linked lists also carry along a pointer to the following node (and the preceding one, for a doubly-linked list). Well, trees do something like that, too. The root node, in addition to its data value, also contains a list of pointers to its children.

These children are root nodes, and thus trees in their own right. Each will have its own data and list of children, and those, in turn, will have the same. If the child list is empty, then that node is at the “end” of one branch; it’s a leaf node. (If there are children, you might be wondering, are there parents? Yes. A node having another node in its child list is that second node’s parent. But data trees are asexual: each child only has one parent.)

Trees are a perfect example of recursion. A tree’s children are also trees—empty ones, if they’re leaf nodes—and they can be treated as such. The most used algorithms lend themselves naturally to a recursive style even in imperative languages. So that’s how we’ll be looking at them here.

Growing a tree

Trees consist of nodes, and each node has two main parts: a value and a list of children. Thus, a simple way of representing a tree is as an object (or similar structure) with two fields, like so. (This example uses TypeScript for illustration purposes.)

class TreeNode {
    value: any;
    children: TreeNode[];
}

Not that hard, huh? It’s nothing more than putting our words into code. A TreeNode‘s value could be anything, though you’d probably restrict it in a real application, and its children are more TreeNodes. Adding, removing, and altering children works in almost the same way as with linked lists, at least with this “basic” tree setup.

Traversing the tree (sometimes called walking it) is a different matter. Here, we want to go through each of the root’s children, then their children, and so on, until we’ve visited every node in the tree. There are two main ways to do this, but the depth-first method is more common and easier to explain. In code, it looks about like this:

function traverse(tree, callback) {
    for (var child of tree.children) {
        traverse(child, callback);
        callback(child);
    }
}

This algorithm is “depth-first” because it visits each of a node’s children before moving to its siblings. This is where the recursion comes into play. We loop through each of the children of the root node. They, in turn, become the roots of a new depth-first traversal. Only when we’ve exhausted the “depth” of the tree—when we reach a leaf node—do we start doing anything. (We’re assuming here that our tree doesn’t have any cycles, child nodes that point to higher levels of the tree. Those make things much more difficult.)

Now, there are a lot of things you can do with this function, but I’ve limited it to a simple, nebulous callback that is run for each node. In the abstract, that’s all there is to it. That simple block of code effectively describes the operation of some code generators, AI systems, and many other complex actions.

Special kinds of trees

The general tree described above suffices for a great many applications. Sometimes, though, it’s more efficient to be more restricted. Computer scientists have therefore developed a number of specializations of the tree for different uses.

The binary tree is probably the most well-known of these. It’s called “binary” because each node has exactly two children: left and right. These children are themselves trees, of course, but empty trees are often represented as null values. Here’s what it looks like in code, once again using TypeScript:

class BinaryTree {
    data: any;
    left: BinaryTree;
    right: BinaryTree;
}

Binary trees add an extra wrinkle to the depth-first traversal we say earlier. Now, we have three possible ways to do things: pre-order, in-order, and post-order traversal. The only thing that changes is when we process the “current” node.

function preOrder(node, callback) {
    if (node == null) return;

    callback(node.data);
    preOrder(node.left, callback);
    preOrder(node.right, callback);
}

function inOrder(node, callback) {
    if (node == null) return;

    inOrder(node.left, callback);
    callback(node.data);
    inOrder(node.right, callback);
}

function postOrder(node, callback) {
    if (node == null) return;

    postOrder(node.left, callback);
    postOrder(node.right, callback);
    callback(node.data);
}

Each approach has its pros and cons. Pre-order works for copying trees, and it’s essentially how expressions are represented in abstract syntax trees or ASTs, an important part of compilers and interpreters. In-order traversal is best for sorted trees, where an extra “key” value is added to each node, arranged so that it’s greater than all the keys in its left subtree but smaller than all those in the right; these binary search trees are used for set structures, lookup tables, and the like. (Maybe we’ll look at them in more detail later in the series.) Finally, post-order is the option of choice for deleting a node’s children and for making RPN expressions.

The binary tree also has a few of its own alterations. The red-black tree uses a “color bit” to keep the tree balanced. This is helpful because most algorithms working on binary trees work best when there the total numbers of left and right nodes are about equal. (In the worst case, all of a tree’s valid descendants are on one “side”. Then, you’re left with just a more expensive linked list.) The AVL tree is a similar variation that has its own pluses and minuses.

B-trees are a special case that sits between binary trees and the general category of trees. They’re allowed to have more than two children, but only up to a certain number. The trick is that each node is given a number of sort keys (like the one in a binary search tree), one for every child past the first. These are calculated so they fit “between” the children, allowing them to serve as index values, speeding up traversal. B-trees are mostly used in databases and filesystems—the two are practically the same thing these days—including the Windows filesystem of choice, NTFS, Apple’s HFS+, and Ext4 and Btrfs on Linux.

Seeing the forest

Trees are everywhere in programming. Whenever you have a set of data with obvious parent-child relationships, it’s probably going to be represented in tree form. Programming languages often don’t offer direct access to the trees, but they’re in there. Sets, maps, and hash tables all use them under the hood. Any kind of parsing, such as XML or a game’s custom scripting language, is going to be tree-based. Even if you never see them, you’ll be using them somewhere.

Fortunately, if you’re not dealing with the innards of the structures themselves, there’s not much you need to worry about. All the hard work has been taken care of. No one needs to manually balance a binary search tree, for instance. But if you work with them directly, it helps to know how they work.

The axioms

Let us consider the following statements as axiomatic:

  1. Principle of Necessity: Government, in some form, is a construct necessary for the creation and function of any collection of people larger than the tribe or village.

  2. Principle of Purpose: A government exists solely to protect the liberty, health, safety, and well-being of its constituents.

  3. Principle of Evolution: A form of government is not cast in stone, but it must have the potential for change.

  4. Principle of Equality: A system of rule that classifies, based on intrinsic factors, some people as greater or lesser in rights or in being is untenable.

  5. Principle of Cooperation: A society of any size is able to achieve greater feats by working in concert rather than in competition.

  6. Principle of Initial Conditions: The Constitution of the United States is not a perfect document, but it is the best available starting point for enumerating the rights of the people and the responsibilities of government.

This set of axioms should be considered a framework, a definition of the boundaries of a space. With logic and deductive reasoning—two qualities sadly lacking in modern politics—it is possible to derive a system of political thought and a model for governance, one which upholds the principles above while remaining rooted in the practicalities of the modern world.

Let’s make a language, part 17c: The body (Ardari)

Ardari, like Isian, is a human language. That makes our lives easier, because we don’t have to worry about alien anatomy, and that’s a big help with Ardari. The phonology and grammar are enough trouble by themselves!

The body

The Ardari body, or apsa, has seven main sections, and that’s a bit of a cross between physiology and philosophy. But that’s how they see it, so who are we to argue?

The first is the chäf “head”. That’s where the mouth (mim) is, so we need it to eat (tum-) and drink (kabus-). The head also has our zhajëlad “hair”, another important part of being human…unless you’re bald.

The head also physically contains the sense organs, but Ardari counts them as part of the brain, sènga. The agya “eye” lets us see (ivit-). To smell (aws-), we use the khun “nose”. The mèka “ear” is how we hear (ablon-). In addition to helping us eat, one part of the mouth, the lèta “tongue”, is used to taste (aty-). Touching (tejv-) is perceived by the brain, too, though the skin (prall) covers the entire body.

The head connects via the ghaf “neck” to the next part of the body: the chest, or ghall. It contains a number of important bones (singular: oqa) and muscles (singular: zuna).

But the chest’s most vital purpose is housing another section of the body: the rocha, or “heart”. The heart, to Ardari speakers, controls the chonga “blood”, one of the essences of life.

Sticking out of either side of the upper body is a kyem “arm”. Bending at the krin “elbow”, it ends at a hand, or kyur. Five fingers (singular: inda) are on that hand, one of which is the special kyu “thumb”.

Farther down the body is the lubrall, the abdomen. It has quite a few interesting bits, but the most pertinent for this post are the legs (singular: khära). Like arms, these have a bending joint, the knee or kubya. And at the end of each is one allga “foot”, complete with five toes (singular: alyinda). Put together, they’re how we walk (brin-).

Bodily functions

People live (derva-) and die (lo-). They sleep (rhèch-) and wake (äske-). And they do so much more.

Lovers will kiss (alym-) and perhaps dance (tatyer-), friends will laugh (jejs-) and smile (miwe-). Those who are sad can cry (ajn-), but someone will often be there to hold (yfily-) them. And that’s only a taste (atyëndasö) of what’s out there.

Word list

As with Isian, this is a larger list of words that contains those mentioned in this post and a number of others created for this topic.

Body parts
  • abdomen: lubrall
  • arm: kyem
  • back (rear): sur
  • blood: chonga
  • body: apsa
  • bone: oqa
  • brain: sènga
  • chest: ghall
  • ear: mèka
  • elbow: krin
  • eye: agya
  • face: sòl
  • finger: inda
  • flesh: tyaza
  • forehead: nèchäf
  • foot: allga
  • hair (single): zhaj
  • hair (collective): zhajëlad
  • hand: kyur
  • head: chäf
  • heart: rocha
  • knee: kubya
  • leg: khära
  • mouth: mim
  • muscle: zuna
  • neck: ghaf
  • nose: khun
  • skeleton: lejoqa
  • skin: prall
  • spine: oqoza
  • stomach: cheld
  • sweat: kwèd
  • tear (drop): osi
  • thumb: kyu (neuter, declined as kyuw-)
  • toe: alyinda
  • tongue: lèta
  • tooth: käga
Bodily terms
  • alive: dervant
  • awake: äskent
  • dead: lont
  • dream: omi
  • fat: vukh
  • sick: blòkh
  • skinny: tris
  • tired: zorant
  • to die: lo-
  • to kill: dyèg-
  • to live: derva-
  • to sleep: rhèch-
  • to wake: äske-
Bodily actions
  • to breathe: dèrèlo-
  • to catch: kòp-
  • to cry: ajn-
  • to dance: tatyer-
  • to drink: kabus-
  • to eat: tum-
  • to hold: yfily-
  • to kick: algèlo-
  • to kiss: alym-
  • to laugh: jejs-
  • to lie (down): dwe-
  • to run: okhyn-
  • to shout: eja-
  • to smile: miwe-
  • to sit: bun-
  • to stand: minla-
  • to swim: tso-
  • to throw: ghur-
  • to walk: brin-
The senses
  • sense: llad
  • smell: awsönda
  • taste: atyënda
  • to feel: luch-
  • to hear: ablon-
  • to listen for: èkhlyd-
  • to look at: tojs-
  • to see: ivit-
  • to smell: aws-
  • to sniff: nyaz-
  • to taste: aty-
  • to touch: tejv-

Indie genres

Being a game developer is hard. Going at it as an indie is that much harder. You don’t have the budget that the big guys have, which means that you can’t afford flashy, state-of-the-art graphics, A-list voice actors, or a soundtrack full of 80s hits. That doesn’t mean that indie games can’t be great. They can, as the past few years have shown. (After I finish writing this post, I’ll probably go back to Sunless Sea, one of those great indie games.)

But the lack of money, and the lack of assets, technology, and infrastructure that it creates, that does have an impact on what an indie dev can do. That’s starting to change, but we’re not quite there yet. For the time being, entire swaths of gaming’s concept space are blocked off for those of us not backed by the AAA guys.

It’s for this reason that some gaming genres are far more common for indies. Those that are the easiest to write, those using the least amount of “expensive” bits, and those that fit within the capabilities of indie-available tools are best represented. Others are rarer, because they’re so much more difficult for a small studio or lone developer.

So let’s see what we can do. I’ve taken the most popular game genres and divided them into three broad categories: those that are very indie-friendly, the ones that indies probably can’t make, and a few that are on the bubble.

The good

  • Puzzles: Puzzle games are some of the first that budding game developers learn how to make, and they’re still highly popular. They’re easy to make, they don’t require a lot of high-quality assets, and people know they won’t be very fancy. Yet puzzle games can be incredibly addictive, even for casual players. These are always a good choice for an indie project, particularly a solo one.

  • Platformers: Another popular genre that perfectly fits the indie mold. Most of the low-cost and free engines have special support baked in for platformers, almost like the creators are steering you towards the genre. And it’s good that they are, as platformers have brought success to quite a few developers over the years. People thought they were dead when the 3D revolution hit, but time has only proven them wrong.

  • Adventure: Adventure gaming is another genre left for dead in decades past. But it also found resurgence in recent years. Point-and-click adventures, survival horror, visual novels, and even interactive fiction have grown in popularity. For indies, adventure is a good genre because it rewards great writing over eye-candy. Art is hard for most programmers, but there are a lot of free assets you can use here.

  • Shooters: First-person or third-person, shooters are popular everywhere. Most of the major engines are tuned for them, and for a while it seemed like that was all the big guys knew how to make. Now, indies aren’t going to make the next blockbuster franchise, but that’s no reason to give up on the shooter genre. Plenty of niche gamers have a favorite shooter. The hardest parts are the assets (but Unity, for instance, has a lot of them available at a decent price) and the multiplayer backend. Get those straight, and you’re golden.

  • Retro: I’m using “retro” as a catchall term for a number of smaller genres that have been around for a long time and are still popular today…in their original forms. Think shoot-em-ups, for example. A lot of people seem to like the retro feel. Pixel art, 8-bit sounds, garish color schemes, and frustratingly difficult gameplay are the rule here, and a subset of gamers will eat that up. In other words, retro gaming is a perfect fit for indies: assets are easy to create, nobody expects them to be good, and you don’t have to worry much about game balance.

  • Sandbox: Ah, Minecraft. The open-world sandbox might be the defining genre of the 2010s, and it’s one that the bigger studios haven’t really tackled very much. Some of the best sandbox games, according to the gamers I’ve talked to, are the indie ones. The genre does have an allure to it. No story needed, AI is only for enemies, the world is made by code, and players will swoon over the “emergent” gameplay. What’s not to love? (Of course, it’s never that simple, but that hasn’t stopped indies from taking over the sandbox space.)

The bad

These next few genres are the ones that don’t seem indie-friendly, but a dedicated developer could make something out of them.

  • Turn-based strategy: Of the strategy variants, I prefer this one for its laid-back nature. But it’s a hard one for an indie. You’ve got two real choices. You can focus on single-player, but then you need a good handle on AI. Or you can make a multiplayer-centric game, with all the problems that entails. Still, it can be done, even as a volunteer effort. Freeciv and Battle for Wesnoth are two examples of free strategy games that have won hearts and minds.

  • Simulation: Sims are another tantalizing genre. They’re a little more complex than their sandbox cousins, often because they have restrictions and goals and such, but most of the same arguments apply. Simulation games also tend to be better focused, and focus is a powerful tool ignored by many devs on either side of the money line. But they’re a lot of work, and it’s a different kind of work. Simulations need to be researched, then written in such a way that they (mostly) reflect reality. Can indies do it? Kerbal Space Program proves they can, but it’s not going to be easy.

  • Role-playing: RPGs, in my opinion, are right on the line of what’s doable for a solo developer. They’re well within the reach of an indie studio, however. It’s not the code that’s the problem—RPG Maker takes care of most of that—but the combination of gameplay, artwork, and writing that makes an RPG hard. That shouldn’t stop you from trying. When done right, this genre is one of the best. Free or cheap assets help a lot here, although you still have to do the storyline yourself.

The ugly

Some genres are mostly beyond indie capabilities. Not that they haven’t given them a shot. Sometimes, it even pays off.

  • Sports: With one exception, sports games are very unfriendly to smaller studios. You’re competing against juggernauts who’ve been at this for decades, and they have all the licenses, endorsements, and publicity. But if you’re willing to invent a new sport, you just might be able to slip into the picture. If you have a bigger budget, that is. It worked for Rocket League.

  • MMO: Just no. MMOs combine all the problems of RPGs with all the hassle of multiplayer shooters, and the whole is much greater, in terms of trouble, than the sum of its parts. Indies have tried, but few have really succeeded. It’s a combination of content and infrastructure that tends to doom them. The general lack of dedicated tooling (MMO-specific engines, etc.) doesn’t help matters.

  • Real-time strategy: The RTS genre is almost dead unless your game is named StarCraft, all but replaced by the MOBA. Either way, it’s a tall order for indies. Strong AI, good artwork, racks of servers to host the multiplayer matches, and the list only grows from there. To top it off, the real-time genres seem to attract more cheaters than just about anything else, so you have to be watchful. But monitoring games for cheating means taking your eyes off the code or hiring moderators. Neither is a good option for a dev on a tiny budget. If you somehow manage it, the payoff can be enormous, because of one recently coined word: esports.

  • Console: This is a platform, not a genre, but it’s worth mentioning here. Thanks to the closed nature of consoles, indie development usually isn’t worth pursuing. Yes, Sony and Microsoft have become more open in the last few years (Nintendo is, if anything, becoming even worse), but there are still too many barriers in the way to make console games a good use of your valuable time. Stick to the three PC platforms (Windows, Linux, and Mac) and the two mobile ones (Android, iOS) at the start.

Magic and tech: construction

Building things isn’t necessarily a sign of civilization and higher thought—birds build nests, for instance, while ants and bees have some seriously elaborate dwellings—but we’ve definitely taken it to another level. Our planet’s surface is covered by billions of buildings, from straw huts to skyscrapers, and many are constructed on the remains of earlier settlements. And that’s only the housing. Add in all those other things we build every single day, from phones to cars, and it’s clear: humans are builders. We always have been.

Beneath the steel rebar and plastic and composite and the other myriad materials, the art of construction hasn’t changed too much over the ages. We’ve developed machinery to automate nearly every aspect of it, but it still boils down to putting pieces together. In general, the addition of magic won’t change that. As we’ll see, it can function as a sort of replacement for the advanced tools available to us but beyond the imagination of our ancestors.

Because this is such a huge topic (even covering only a small corner of it, as we’ll do here), I’m going to break this up into a few smaller sections, each focusing on one aspect of construction and how magic affects it. We’ll start with the first step in building anything: gathering the materials.

Materials

Look around you, and you’ll likely see lots of modern inventions. Computers, phones, televisions—in other words, tech. But take a closer look. Think about the building you’re in, its walls and doors. Things like that. It all had to be built from something, right?

Nowadays, we’ve got a huge variety of materials, especially synthetic ones. Plastic, in the colloquial sense of the word, is a comparatively recent invention, dating back to the 1800s. Aluminum, though found all around us, only started to be used as a component of construction around the same time. Silicone is 20th-century stuff, as are the silicon-based transistors in your computer’s CPU.

In older days, your choice of materials was far more limited. You’ve got metals and alloys, but only those accessible to earlier technology, such as iron, copper, tin, and lead. Wood, clay, and stone are natural and abundant, and they come in lots of styles, each with its own pros and cons. Plants provide fibers, best known for their role as cloth, while animals offer hide, bone, horn, and ivory. Added to these are a small assortment of classical “synthetics”, such as concrete (known to the Romans, among others), glass (at least five thousand years old, not counting natural obsidian), and rubber (derived from plants native to Central and South America).

What can magic add to that? The same thing that technological advances did. We can’t quite get to nylon or graphene, but we can make some advancements. The easiest way to do that is by adding fire: some of the better materials require higher temperatures than early medieval forges can achieve. That’s what it takes to melt tougher metals, for example. (Colder conditions aren’t nearly as helpful, however.)

Most synthetic materials, on the other hand, are created by some sort of chemical process. For that, you need the chemical (or even alchemical) knowledge that comes naturally from the growth of science. Since we’ve already established that the study of magic in our fictional world will increase experimentation and theory, it’s not a great leap to push that same outlook into metallurgy and the study of materials.

Steel, to take one notable example, was notoriously difficult for our predecessors, but magical tech could allow it to be common enough that any old adventurer could wield it. Better control over heat sources and impurities are the reason why, and they give us a number of other advances. Cheaper glass—especially clear plate glass—and ceramics are another good illustration. And if you posit a magical source of electricity (and the understanding of it), then electrolysis nets you aluminum and a number of other niceties.

For our magical society, we won’t go quite that far. They’ve got a good handle on steel, though, to the point where it’s not necessarily the mark of a rich man to have a lot of it. Similarly, quality iron is cheap, and good glass is available. And that’s in addition to the natural set above. (We’ll follow the typical fantasy tropes and say that concrete belongs to an earlier age, its secrets forgotten.) Chemistry is a growing art, but its byproducts aren’t available on an industrial scale…yet. So not too much changes, or so it seems.

Tools

The tools of the carpenter’s trade have changed dramatically in the two thousand or so years since history’s most famous practitioner of the craft. My stepdad builds houses for a living, and while he does have a set of manual hammers, saws, and the like, he won’t be using them on the job under normal circumstances. Today, it’s all about nail guns, automatic drills, compressors, generators, and an assortment of saws and sanders and similar implements.

Tools for working with materials reflect the work done, whether in modern, automated form or as the old-fashioned hand tools of yore. Saws are meant to cut, but not in the same way as, say, a knife; teeth work better than a smooth blade for breaking the thick fibrous bonds of wood in a back-and-forth motion. But splitting logs is best done with a wedge, and axes make excellent wedges. Hammering is all about applying force, and a heavy weight does wonders there. And so on.

For most of history, all these things were hand-operated. Most of the time, anyway. There have always been attempts at power tools. Hydraulic (from water) and pneumatic (from air) pressure have always been favorites; compressed air still works well today, assuming my stepdad’s compressor is in the mood to cooperate, which is never a guarantee. Only in recent times have we been able to convert electricity into the motive force necessary for tools, though heavy machinery has been able to use steam for a couple hundred years.

And that may be one of the best parallels for magical tools. We’ve already seen the application of magical force for such uses as transportation, so it’s no stretch to see how it could be incorporated into mundane tools. Our fictional realm can create magic-powered jackhammers, drills, and nail guns, all of which work far better than their hand-operated cousins, if not as well as modern gadgets. Saws? No problem. Cranes? Sure. How about a nice belt sander? We can do that, too.

But wait, as they say, there’s more. Tools aren’t just about force. What about a blowtorch that uses magical fire? That’s also possible, and probably safer than a tank of acetylene, if properly designed. Soldering and welding both benefit from that, as well, making everything from piping to stained glass cheaper and more widespread. And that’s not even counting what a full-fledged mage could do on the job.

Labor

Old tools were mostly human-powered, and that obviously means you’ve got to have humans to power them. Construction, especially from the house level on up, requires a lot of labor. Traditionally, that meant companies of hired laborers (or, in less-friendly areas, slaves) working tirelessly on the project du jour. With most tasks being done by hand, there wasn’t much choice.

Magic brings something like automation, and we know how automation affects the labor market. You only have to turn on the news to find out. (I’m writing this a couple of days after the “Brexit” vote, and from a state in the US that is seeing a resurgence in manufacturing…but one that doesn’t benefit unskilled labor. That’s all robots, or it will be soon.) As the use of self-powered tools grows, the need for massive numbers of low-wage laborers declines. The Industrial Revolution would have killed slavery without the abolitionist movement, just as the Robotics Revolution is killing the blue-collar job market today. (How that changes the economy is worthy of its own series of posts.)

So our magical society will be slave-free, both out of a concern for our fellow man and a lack of need for slaves as laborers. That doesn’t mean there won’t be any builders, however. Somebody has to work those tools, and somebody has to make them. But it’ll be a bit more like the year 2000 than 1000. Machines won’t be too widespread, but powered tools will be common enough that most have seen them in action, if not used them.

Under construction

I could go on forever, and with a much more informed opinion than usual, thanks to my family situation. But I won’t, because I think you get the picture. Our magical realm will be building in a way that should be fairly recognizable: small to medium teams of workers with semi-automatic tools. With magic, they are more efficient than their real-life counterparts, so the work gets done sooner. That implies more building, whether upward or outward, and the better materials will certainly help the former. Towers, pyramids, and other magnificent works were accomplished without magic, but this realm might be more prone to creating such masterpieces. They’ll have the means, and the time will come when there’s nothing better to do.

Let’s make a language, part 17b: The body (Isian)

Isian speakers, as we have stated, are ordinary humans living on a slightly altered Earth. Thus, they have human bodies, human senses, and human needs. That makes things much easier for us conlangers, at the expense of being a bit less interesting. But we’ve already made that decision; it’s too late to turn back now.

Parts of the body

The Isian language has a lot of terms for the various parts of the human body, but we’ll only cover some of them here. Otherwise, this post would be far too long.

In Isian, the body is har. That could be any body, but it’s also specifically a human one. Bodies are covered in kirot “skin”, placed over nush “flesh” and colosi “bones”. Those bones make up the colohar “skeleton”, with its center at the caycha “backbone”.

One of the most important parts of the body is the head, gol. Not only does it hold most of the setes “senses”, but it’s also considered the center of the self in Isian philosophy. But that’s a different post entirely. From a physical standpoint, we can see the bisi “eyes”, nun “nose”, ula “mouth”, and pos “ears”. The mouth also contains the teeth (teni) and tongue (dogan), and the whole head is topped by pel “hair”. And, of course, the head also holds the brain, sayban.

Moving down, we see the if “neck”, which leads to the sinal. That word represents either the torso as a whole or just the chest, with dosar standing for the lower half. Two of the more important organs inside the sinal are the heart, sir, and the stomach, go.

Except for an unlucky few, Isians have two toni and two duli, “arms” and “legs”, respectively. At the end of each arm is a fesh “hand”, with four ilcas “fingers” and a dun “thumb”. The legs, on the other hand, have puscat “feet”, each with five chut “toes”.

Senses and perception

Isian speakers recognize the same five senses (setes) we do. They can chere “see”, mawa “hear”, cheche “taste”, nore “smell”, and shira “touch”. And each of these has a corresponding “abstract” noun representing the sense. For example, the sense of smell is norenas, and taste is chechenas.

Actions

The body can do many amazing things, and Isian has words for all of them, but we’ll only showcase a few here.

People have to hama “eat”, and that’s a verb we’ve encountered a few times in this series. They also like to jesa “drink”. We must hifa “breathe”, as well, but that one’s not as exciting.

When we’re sad, we might acho “cry”, and when we’re happy, we’ll shira “smile”. If we get tired (taprado), it’s time to deya “lie down” and then inama “sleep”. But we will ture “wake” the next morning.

And finally, we all liga “live”, but, as they say, all men must nayda “die”.

Word list

Here’s a full list of new words made for this part, including some that weren’t mentioned above, and the other “bodily” words that we met earlier on in the series. They’re mostly divided into the same categories as in the post.

Body parts
  • abdomen: dosar
  • arm: ton
  • back (rear): bes
  • blood: miroc
  • body: har
  • bone: colos
  • brain: sayban
  • chest (torso): sinal
  • ear: po(s)
  • elbow: copar
  • eye: bis
  • face: fayan
  • finger: ilca(s)
  • flesh: nush
  • forehead: golamat
  • foot: pusca
  • hair (single): pardel
  • hair (collective): pel (or pardelcat)
  • hand: fesh
  • head: gol
  • heart: sir
  • knee: gali
  • leg: dul
  • mouth: ula
  • muscle: wachad
  • neck: if
  • nose: nun
  • skeleton: colohar
  • skin: kirot
  • spine: caycha
  • stomach: go
  • sweat: wec
  • tear (drop): ger
  • thumb: dun
  • toe: chu
  • tongue: dogan
  • tooth: ten
Bodily terms
  • alive: ligado
  • awake: turedo
  • dead: naydo
  • dream: wish
  • fat: khol
  • sick: peg
  • skinny: jit
  • tired: taprado
  • to die: nayda
  • to kill: acla
  • to live: liga
  • to sleep: inama
  • to wake: ture
Bodily actions
  • to breathe: hifa
  • to catch: sokhe
  • to cry: acho
  • to dance: danteri
  • to drink: jesa
  • to eat: hama
  • to hold: otasi
  • to kick: kuga
  • to kiss: fusa
  • to laugh: eya
  • to lie (down): deya
  • to run: hota
  • to shout: heyde
  • to smile: shira
  • to sit: uba
  • to stand: ayba
  • to swim: sosho
  • to throw: bosa
  • to walk: coto
The senses
  • sense: sete(s)
  • smell: norenas
  • taste: chechenas
  • to feel: ilsi
  • to hear: mawa
  • to listen for: lamo
  • to look at: dachere
  • to see: chere
  • to smell: nore
  • to sniff: nisni
  • to taste: cheche
  • to touch: shira

Statistical sampling in JavaScript

It’s 2016, and that’s an election year, which means we’ll be spending the rest of the summer (and half of the fall) watching America’s most ridiculous spectator sport. The pundits and panels and polls are all quite fun, but I find that the methodology is far more interesting than the results.

One of the greatest weapons in the pollster’s arsenal is sampling, and one of those footnotes you’ll see in opinion polls in the coming weeks is the margin of error. These are basic concepts of statistics, but most people might not know how they work. Worse, some programmers might not. So here’s my attempt at rectifying that.

Definitions

Sampling is, in effect, a way of drawing conclusions about a population (such as a state or country) based on surveying only a small fraction of its members. It’s not perfect, but it turns out that, say, 500 people are actually a pretty good indicator of the rest of the nation…as long as you pick the right 500 people. In terms relatable to current events, a presidential poll that only asks people from rural parts of the South is going to get very different results from one that surveys nothing but New York City. That’s selection bias, and it’s one of the hardest things for pollsters to avoid. They’ve got a few ways around it, such as cold-calling random phone numbers, but it’s always a battle.

That very randomness is why sampling works in the first place. If you truly choose your data points (i.e., the people you ask) randomly, then they will, when put together, approximate the “true” nature of things. The more you get, the closer your picture is to the real thing. Eventually, as you’d expect, your sample size approaches the total population; at that limit, the sample obviously represents the whole to perfection.

For smaller samples, however, things aren’t so perfect. Let’s say we have two candidates: H and T. (You get no points for guessing what those stand for.) In “reality”, they aren’t quite even. Say that H has 50% of the vote, T has 45%, and the remaining 5% are undecided, independent, or whatever. Now, take some sort of random number generator and set it to give numbers from 1 to 100. Everything up to 50 is a “vote” for candidate H, 51-95 are for T, and 96-100 are undecided.

After a single generated number, you’ve got a score of 1 for one of the three, 0 for the other two. Not very predictive, but keep going. With a sample size of 10, my results were H 6, T 3, and 1 undecided. Yours might be different, but notice that that’s already looking a lot closer to the true numbers. Give it 100 tries, and it’s probably even better. (Doing this three times with a different generator, my results were: 52 T, 44 H, 4 undecided; 48 T, 47 H, 5; and 57 T, 40 H, 3. Clearly, this RNG leans right.)

The larger the sample size, the more likely the sample will match the population. If you don’t mind a bit of math, then we can look at just how good a match we can get. The basic formula is e = 1 / sqrt(N), where N is the sample size and e is the margin of error. So, for our sample size of 100 above, the math says that our expected error is somewhere within 1/sqrt(100) = 1/10 = 0.1, or 10% either way. Or, as the polls put it, ±10%. Most samples like this are assumed to be conducted at a 95% confidence interval; this basically means that there’s a 95% chance that the true results lie within that margin. (Note, however, that our third poll in the last paragraph didn’t. It’s an outlier. They happen.)

As counter-intuitive as it may seem, this formula doesn’t really depend on the population size at all, as long as the sample is sufficiently small in relation. For national polls surveying a thousand or so people, that assumption holds, so they can safely tout a margin of error of ±3% from their sample of 1,016.

The code

Now we’ll look at how you can do your own sampling. This isn’t just for opinion polls, though. Any kind of analytics could make use of sampling.

The basic function, in JavaScript, would look something like this:

/*
 * Select `k` random choices from a population
 */
function sample(population, k) {
    var psize = population.length;
    var choices = new Set();
    var result = [];

    // Choose `k` elements from the population, without repeats
    for (var i = 0; i < k; i++) {
        var ch;

        do {
            ch = Math.trunc(Math.random() * psize);
        } while (choices.has(ch))

        choices.add(ch);
    }

    for (var c of choices) {
        result.push(population[c]);
    }

    return result;
}

As always, this isn’t the only way to do what we’re trying to do, but it’s very close to what Python’s random.sample function does, so the idea is sound. To get our sample, we generate a number of array indexes, and the Set guarantees we won’t get any repeats. Our result is a new array containing only those elements we chose. We can then do whatever we need.

But how do we determine what sample size we need? Well, one way is to work backwards from the margin of error we want. Remember that this usually won’t depend on the size of the population.

/*
 * Given a desired margin of error,
 * find an appropriate sample size.
 */
function sampleSize(margin) {
    return Math.round(1 / (margin*margin), 0);
}

This is nothing more than a rearrangement of our formula. Instead of saying e = 1 / sqrt(N), we move things around to solve for N: N = 1 / e^2. Rounding to the nearest integer is just for convenience.

In a nutshell, that’s all there is behind those opinion polls you’ll be hearing so much about over the coming months. Pick enough people at random, and you’ll get a picture of the general populace. It’ll be a blurry picture, but even that’s enough to make out some of the larger details.

Building aliens – Biochemistry

What is life? At the most basic level, we’re not entirely sure. We’ve got a lot of good theories that accurately explain most of life’s inner workings, but there are quite a few loose ends. We don’t, for example, truly know how life began, nor do we know if it exists on other worlds. (Not that we don’t have a few candidates elsewhere in our solar system: Mars, Europa, Enceladus, Titan…)

All life on Earth works in about the same way, however, and we’re pretty sure we know how. It’s all based on the same fundamental building blocks, the same chemical and biological processes—processes that are not the only way to do things. When you get right down to it, we have more in common with the smallest bacteria than we probably would with any extraterrestrial, unless you invoke some sort of higher principle. As of yet, that’s uncalled for, considering we have a total biosphere sample of 1, but who knows?

The way it is

Earthly life is based on carbon. There’s no question about that. In fact, carbon is so important to life that it’s a requirement for a chemical compound to be called organic. (Think about that the next time you see “organic salt” for sale. Table salt is mostly sodium chloride, NaCl. No carbon there.)

Carbon is a great element for life, as countless astrobiologists and writers of science fiction have discovered over the years. It’s very stable, and it’s good for forming long “chain” molecules, or polymers. It readily bonds with lots of other molecules, and the compounds made from that are…interesting, to say the least. Things like carbon dioxide, sodium bicarbonate (baking soda), hydrogen cyanide, and, of course, ethanol.

But life is more than carbon. We also need a solvent, and nothing works better than plain old water. It’s perfect as a medium for the biochemical reactions necessary for life. Water has a relatively large liquid region (0°C to 100°C, or 32°F to 212°F), and it’s a fairly simple compound (H2O). It’s essentially neutral, so it doesn’t affect the reactions as much as other liquids might. Oh, and it covers about 70% of our planet’s surface, so there’s that.

Other elements find their way into Earth life besides carbon, hydrogen, and oxygen. Nitrogen is a big one; percentage-wise, there’s more of it in the air than there is water on the surface, so life would be silly not to do something with it. Phosphorus, despite its volatile nature, is relatively stable once it’s bonded to a bunch of other atoms, and it’s the backbone of adenosine triphosphate (ATP), one of the most important complex molecules at the cellular level. Calcium is needed for our bones. Iron is what makes our red blood cells, well, red. Sulfur, potassium, sodium, magnesium, and a dozen or so other elements are all vital for us and most other life as we know it.

On Earth, as we know, life is made from DNA. We all know the double helix that is its form, and some might recall the scene in Jurassic Park explaining DNA and the genes made from it. From another point of view, DNA is like a computer program: a series of “instructions” that make a blueprint for life. But from a biochemical standpoint, it’s nothing more than four moderately complex molecules organized on a pair of polymer chains. These four nucleic acids bond in pairs across the chains; strictly speaking, only one chain is necessary, as in the similar (but single-stranded) RNA.

One of DNA’s functions is to encode which higher molecules are needed where. These large polymers are proteins, and they’re made up of smaller parts called amino acids. In the genetic code (on our planet, at least), three nucleic acids in the DNA chain represent an “instruction” for an amino acid. We use about twenty of those. So do dogs. And trees, mushrooms, and any other “complex” life you can think of. Bacteria use a slightly different set, but even their genetic code is built around the same twenty.

To a chemist, that’s life: a bunch of molecules acting and reacting, bonding with each other, splitting apart. What makes it unique is the fact that it can do this in such a way that it perpetuates itself. Life, once it gains a foothold, will reproduce as long as it can. That’s why the “life on Mars” debate is so polarizing: if life did exist on Mars for any serious length of time, then it would have spread all over, and some evidence should be relatively easy to find even after a billion years.

True, there’s a difference between any old kind of life and the sentient, sapient species we expect when we think of aliens. But life like that didn’t spring fully-formed. By all that we know, it had to come from somewhere, and it likely came from the same place that every other living thing on its planet did. (One hypothesis, however, argues for a shadow biosphere, a whole set of lifeforms unrelated to anything we know, yet still living all around us.)

The ways it could be

The four basic elements of organic life—carbon, oxygen, nitrogen, and hydrogen—are everywhere. They’re common here, and they would be in just about any hospitable world you could imagine. Life would almost be expected to use them. Carbon, because of its polymerization qualities, is the best backbone of the four. Hydrogen and oxygen make good compounds, notably water, but also—when bonded to carbon chains—sugars and carbohydrates. Those may sound like dirty words to a health nut, but we can’t live without them (in moderation). Nitrogen isn’t of much use on its own, but throw it into molecular compounds, and it’s suddenly great.

For “life as we know it”, those four are the big ones. It’s the trace elements that will be in different concentrations. Phosphorus and calcium are important for us because of their chemical properties; it’s not entirely unreasonable to imagine alien life using them for the same purposes. The rest, though, are fair game. It’s possible that alien organisms could find ways to use elements and compounds that are toxic for us, such as heavy metals (lead, mercury, etc.).

All life on Earth is based on DNA (or its precursor, RNA), but that’s not a given. Rather, the form isn’t a given. Complex life does need some way of replicating, something resilient, resistant to random mutations, yet easily formed from common materials. Chemists have created a chain of peptides that can hold nucleic acids. And those nucleic acids don’t have to be our familiar four. Xanthine, for instance, is chemically related to adenine and guanine, and it’s found throughout the body.

Even if you have DNA, even if it functions the same way as ours, that still doesn’t mean you’re Earthly life. A simple bit of multiplication shows that there are 64 possible ways to code amino acids. But we barely use a third of that space. Most amino acids have multiple, redundant encodings, probably for added security against mutations. Mix up some of those encodings or add different options for amino acids, and you’ve got a whole new way of life.

Another option to look into is chirality. Amino acids are peculiar molecules; they can appear in one of two forms that are identical in composition, but slightly altered in shape. Chemically speaking, they’re called isomers, and life on Earth overwhelming prefers a specific shape for them. But “opposite” amino acids could be the basis for life on a different planet. That life might be otherwise terrestrial, but utterly incompatible with our proteins, enzymes, and so on. (Mass Effect used this idea in a couple of places.)

More alien

As much as any kind of life can be considered common, most alien aficionados expect ours to be so. Carbon, water, and DNA/RNA work. We’re living proof of that. Anything that uses those will be “like us”, at least at the most basic level. But can we change even that?

The problem with designing an alternate biochemistry is that it’s entirely hypothetical, and it will remain so for the foreseeable future. That hasn’t stopped some from trying, and they’ve come up with a few ideas that are scientifically possible, if not necessarily plausible.

Silicon is the favorite of sci-fi, and it also has its proponents in “serious” scientific work. Looking at the periodic table and the very ground beneath your feet, you’d think it was ideal. It’s a heavier analog of carbon, able to form polymer chains by bonding with itself, with hydrogen and oxygen and a few other molecules attached to the sides. But its added mass renders it less common, less stable, and less…free. Silicon doesn’t have the same breadth of possibilities as carbon, and many of its more interesting compounds aren’t suitable as the basis for life. Still, it does have some potential, though it would take an entirely new subfield of chemistry to explore that potential.

Sulfur, as a core element, is another possibility. It can form long chains like carbon, and it’s a bit more common than silicon. But its downfall is again in the “organic” chemistry. Those long chains are all linear. They don’t branch, and branching carbon chains are responsible for the vast array of organic molecules we know today. That doesn’t mean sulfur-based life is impossible, but it doesn’t look like it could become complex. On the other hand, sulfur can be—and is—used instead of oxygen in some lifeforms. (Bacteria that do this on Earth are used to create hydrogen sulfide, H2S, the sulfuric analog of water.)

Metallic life could use any of the more common metals as a basis. We haven’t explored much of this sort of chemistry, but titanium and a few other metals are potential candidates, particularly in high-temperature, high-pressure environments. Apart from the practicalities of using a heavier, rarer element, the lack of knowledge on this subject is what keeps us from positing “metallo-organic” life.

Arsenic is mostly poisonous for Earthly life. The very reason why it’s toxic is the same reason why it could be a potential alternative for life: it’s in the same atomic class as phosphorus. It reacts with many of the same molecules as phosphorus, “competing” with it. That’s what makes it harmful to us, but other life could use it in something like DNA. That was actually the working hypothesis for a strain of bacteria found a few years ago in California. (That claim has since been discredited.)

For solvents, authors both serious and fictional have devised a host of possibilities beyond “just add water”. Ammonia could work, but only at much lower temperatures (or higher pressures) than on Earth. And ammonia is flammable, so oxygen-breathing organisms would find it problematic, to say the least.

Another option, one that has a few scientists awfully excited, is methane. It’s a very simple hydrocarbon (CH4), it’s fairly abundant in the universe, and—under the right conditions—it’s pound-for-pound as effective as water. Methane also has the bonus of being related to bigger hydrocarbons like ethane, some of which could also be used by life. Imagining a “sea” of liquid hydrocarbons isn’t even that hard. We’ve got three of them in our solar system: Titan’s Kraken, Ligeia, and Punga. And there are indications from that moon of something that could be life-related.

The list of also-rans is long, and getting longer all the time. In addition to ammonia and methane, people have imagined life using as solvents everything from hydrogen sulfide to peroxide to silicon dioxide, AKA glass. All of them have their drawbacks, usually coming from the range of temperatures where they are liquid. But don’t let that stop you from trying.

Finally, there are a few ideas that are even more “out there”. Clouds of Venus? Sure. Charged dust inside a plasma sitting in space? Yeah, that could work. Life on a neutron star? A bit harder, but we can work something out. None of those would resemble life as we know it, though. Indeed, we might not even recognize them as living, although they would fit every definition.

Next time

So…life is complex, you see. This was only a basic overview of one aspect of it, and it’s one of the longest posts I’ve written. And truth be told, most writers won’t need any of it. Unless you want to be wild and weird, you’ll probably stick with something Earth-like: carbon, water, DNA, etc. And that’s okay. You can still make great aliens while staying inside those borders. Such life is far easier to see as alive, too, although it will almost certainly resemble nothing on our planet. (And forget about eating it. The proteins and enzymes and such will probably be completely different.)

In the next part, we’ll switch from biochemistry to actual biology, as we look at evolution and how it makes possible the variety of life in a biosphere. Aliens, like us, will evolve. They may not have genes like we do, they may not reproduce in the same way, but they’ll evolve. Next month, we’ll see how and why.

Let’s make a language, part 17a: The body (Intro)

Humans are conceited beings, if you think about it. A great portion of the vocabulary of any language is dedicated to talking about ourselves. About our bodies, their parts, the things they can do. In fact, the field of bodily language is so big that there’s no way I could put it all into a single post, so this part will have to be restricted to just a small portion of it: the bodily organs, the senses, and the actions involving either.

Head to toe

You should have a good idea of what goes into a human body. After all, you’ve got one. We’re animals, mammals, primates…but we’re also humans, descendants of Homo sapiens. Our bodies are all our own, but they follow the same general blueprint evolution has given us. The way we speak of those bodies flows from that, but cultural influences are also in play here. The terminology of the body in English, for example, is a melting pot of ancient words, technical terms, loanwords, and colorful euphemisms. Other languages aren’t much different, though the ratios of these four categories will differ.

But let’s start with the body itself. Look at yourself in the mirror, and you’ll see the basic outline of the human body. We’ve got three major segments, as you might vaguely recall from science classes: the head, thorax, and abdomen. Nobody really talks about those last two in that way, however. Instead, we speak of the chest, the torso, and so on. That’s probably because the idea of humans as segmented creatures came about comparatively late, and as a more scientific endeavor.

The head, though, is the most important. It’s what we look at first, and it’s where we look out from. The head is centered around the brain, and most of our sense organs are arranged around it. We’ve got the eyes, ears, and nose for the senses of sight, hearing, and smell, respectively. The mouth, with its teeth, tongue, and lips, is used for taste, eating, and speech. On top (for most of us), we’ve got the hair—the full covering on one’s head can have the same word as an individual strand, or there can be a count/mass distinction. Other, less interesting bits include the forehead between the eyes and hairline, the cheeks on the sides, the chin at the bottom, etc.

Our heads are connected to the rest of our bodies by the neck on the outside and the throat inside, with skeletal support provided by the spine or backbone, which runs from the brain all the way down the torso. The chest is largely self-explanatory, though it does show one of the sexual differences in our species, the breast. The abdomen’s important parts are all on the inside, except for the buttocks and that other distinguishing characteristic, the sex organs or genitals.

We’ve also got four limbs (unless you’re one of the unlucky ones that had one or more amputated). These come in pairs, because symmetry is good. The arms are up top, ranging from the shoulder where they meet the torso, down the upper arm (English doesn’t have a specific term for this, but other languages do) to the elbow, then to the forearm and the wrist, finally ending at the hand. Hands have a palm and five digits: four fingers and a thumb, with the latter sometimes grouped as a fifth finger. The fingers have joints—the knuckles—and a protective covering, the nail or fingernail.

Our other pair of limbs took a different evolutionary path, thanks to our bipedal nature, but most of their parts have analogies in the arms. The leg begins at the hip, the abdominal counterpart to the shoulder. Down from this is the thigh, which ends at the knee. The knee then gives way to the calf, then the ankle, and finally to the foot. Feet, like hands, have five digits, the toes, but these are less distinct than their upper-body cousins. The bottom of the foot is our interface to the ground, and it is contains the heel at the back and the ticklish sole in the middle.

Lastly, the entire surface of the body is covered in skin. The fingers and toes have nails, as mentioned above. And hair is everywhere, although it’s at its thickest on the head. Sometimes, the thinner hair in other parts of the body grows thicker; the most common regions for this are the chest, armpits, pelvis, and back. Languages might choose to acknowledge this fact with a separate word, but it’s more likely that they’ll use phrases, as in English “chest hair” and “pubic hair”.

Internal affairs

That about covers the exterior of our bodies. Now, it’s on to the insides. We all have a skeletal structure made up of bones, with the spine being the most important set of those. Some of those bones have common names, and many others have medical or scientific ones; besides the ribs, most conlangs won’t need them for a long time.

Bones give us our shape, but we’re powered by blood. It flows throughout the body in various vessels, including the arteries, veins, and capillaries. As with the names of individual bones, these aren’t necessarily terms beginning conlangers need to worry about, but you can put them on your checklist. Other bits of the body’s interior that you might want to name include fat and muscle, mostly treated as substances rather than body parts. (Except, of course, when you pull a muscle. Then you’ll know that it’s there.)

The organs are the big boys, though. These are the systems that make our bodies work. The brain’s the main thing, and we met it above. The heart, the body’s pumping station, is next on the list, and the lungs are the third member of the all-important trinity. Most of the other internal organs are concerned with one of three things: eating, reproducing, or removing waste. Those that have common names include the stomach, liver, and kidneys, among others. And modern medicine has names for everything, something to keep in mind if you’re making a futuristic conlang.

Actions of the body

Our bodies can do many things, some of them even wonderful. Most of the main verbs regarding bodily actions, however, fall into three groups. Sensory verbs are those that indicate the use of the five senses: see, hear, smell, taste, and feel. English, among other languages, also has a set that connotes the “intentional” use of some of these. In addition to passively seeing and hearing, we can actively look for and listen for.

Another set concerns the use of various parts of our body to perceive or move through the world. We can hold with our hands or touch with our fingers, and our feet and legs help us to walk or run. Although it’s more of a mental task than a physical one, we can also think or perceive. Linguistically, many of these verbs will be intransitive or even impersonal, except those that directly affect something other than ourselves.

The third main class of body verbs is concerned with making the body work. We eat and drink and breathe to provide the necessary inputs, for instance. Most of the “other” end of things is represented by a collection of verbs, and that brings us to a point important enough to earn its own section.

The body and taboo

Probably nothing else in the world is the subject of more cultural factors than the human body. Peoples from all around the world routinely censor their own speech when talking about it, resorting to paraphrases and euphemisms when discussing it. Uncountably many slang terms are dedicated to (or derived from) its function. The body, as thousands of years and billions of speakers can attest, is taboo.

These taboos are not random or idiosyncratic. They’re the result of cultural and linguistic evolution, a consensus of a language’s speakers (sometimes intentionally, as in the banning of certain words, but just as often a subconscious following of unspoken etiquette). They’re very much enduring, and they are not at all identical across language borders.

What parts of the body are most likely to be considered verboten very much depends on the surrounding culture. For many, anything coming from the insides is unworthy of “proper” speech. This includes bodily waste, an area where standard English has no fewer than four different forms, including a vulgar, a scientific, a mild “standard”, and a special form for speaking to children. Some go further, putting blood and spit into the vulgar category and requiring euphemisms for them. (In older English, this was the case specifically for Christ’s wounds, one of the causes leading to “bloody” as an expletive.)

Reproductive organs and acts are another area of taboo. For all that we, as a species, love having sex, we certainly don’t like to talk about it, at least not in direct terms. A few simple searches should net you more terms in this category than you ever wanted to know, from F-bombs and C-words to things you never knew you never wanted to know.

In your language

The body of words (see what I did there?) about the human form is enormous. Fortunately for conlangers, you don’t have to tackle it all at once. Most of the major parts of the body have their own basic words, and that holds true across many languages. In English, for example, the only big areas that use derived terms are the forehead, eyelid, eyebrow, forearm, and armpit. Everything else is fairly isolated, so you can make the words as you need them.

It’s also possible to be more distinctive than English. One way to do this is by naming those parts that we don’t have a single word for. The fingers, for example, do have English names. They’re the index, middle, ring, and little fingers. But why does on the smallest have its own name: pinky? That doesn’t have to be the case; many languages do have separate terms for all the fingers. (And some of those use them for counting.)

Most of our “medical” terms for the body ultimately derive from Latin and Greek, our historical educated languages. For an auxlang, it’s a very good idea to follow that trend. They’re internationally known at this point. Artlangs, on the other hand, might want to do things differently. Those in a fictional world could have their own ancient “learned” language, from which the vernacular borrowed its names.

And don’t forget about taboo, slang, and the like. The body, as important as it is to us, is frequently a very private affair. In polite company, we throw up, but among our friends, we’re happy to puke. We’ll teach a child to pee-pee, but a doctor will tell you to urinate. When talking about our own bodies, we come perilously close to speaking a different language entirely.

Next time around

After the usual trips to Isian and Ardari, we’ll be back here for another round of vocabulary. The focus of the next few months will be on the world itself. First, we’re going to look at the lay of the land, where we’ll gain a whole new set of “natural” geographical terms. Then, we’ll see the plants and flowers and trees that inhabit that land. And Part 20 of the series, hopefully coming in October, will see us journey through the animal kingdom.

If all goes according to plan, that’ll mark a time for me to take a break. But never fear. The series isn’t even halfway over. There’s a whole universe of possibilities left to explore.