Let’s make a language – Part 14a: Derivation (Intro)

By this point in the series, we’ve made quite a few words, but a “real” language has far more. English, for instance, is variously quoted as having anywhere from 100,000 to over a million different words. How do they do it? Up to now, we’ve been creating words in our conlangs in a pretty direct manner. Here’s a concept, so there’s a word, and then it’s on to the next. But that only takes you a very short way into a vocabulary. What we need is a faster method.

Our words so far (with a few exceptions) have been roots. These are the basic stock of a language’s lexicon, but not its entirety. Most languages can take those roots and construct from them a multitude of new, related words. This process is called derivation, and it might be seen as one of the most powerful weapons in the conlanger’s arsenal.

How to build a word

Derivation is different from inflection. Where inflection is the way we make roots into grammatically correct words, derivation is more concerned with making roots into bigger roots. These can then be inflected like any other, but that’s for after they’re derived.

The processes of derivation and inflection, however, work in similar ways. We’ve got quite a few choices for ways to build words. Here are some of the most common, with English examples where possible.

  • Prefixes: morphemes added to the beginning of a root; “un-” or “anti-“.
  • Suffixes: morphemes added to the end of a root; “-ize” and “-ly”.
  • Compounding: putting two or more roots together to make a new one; “football” or “cellphone”.
  • Reduplication: repeating part or all of a root; “no-no”, “chit-chat”.
  • Stress: changing the stress of a root; noun “permit” and verb “permit“.

Stem changes (where some part of the root itself changes) are another possibility, but these are more common as inflections in English, as in singular “mouse” versus plural “mice”. Tone can be used in derivation in languages that have it, though this seems to be a little rarer.

Also, although I only listed prefixes and suffixes above, there are a few other types of affixes that sometimes pop up in derivation. Infixes are inserted inside the root; English doesn’t do this, except in the case of expletives. Circumfixes combine prefixes and suffixes, like German’s inflectional ge-t. The only English circumfix I can think of is en-en, used to make a few verbs like “enlighten” and the humorous “embiggen”. Finally, many languages’ compounds contain a linking element. German has the ubiquitous -s-, and English has words like “speedometer”.

Derivations of any kind can be classified based on how productive they are. A productive derivation is one which can be used on many words with predictable results. Unproductive derivations might be limited to a few idiosyncratic uses. These categories aren’t fixed, though. Over time, some productive affixes can fall out of fashion, while unproductive ones become more useful due to analogy. (“Trans-” is undergoing the latter transformation—ha!—as we speak, and some are pushing for wider use of the near-forgotten “cis-“.)

Isolating languages are a special case that deserves a footnote. Since the whole point of such a language is that words are usually simple, you might wonder how they can have derivation. Sometimes, they will allow a more “traditional” derivation process, typically compounding or some sort of affix. An alternative is to create phrases with the desired meaning. These periphrastic compounds might be fixed and regular enough in form to be considered derivations, in which case they’ll follow the same rules.

What it means

So we have a lot of ways to build new words (or phrases, for the isolating fans out there) out of smaller parts. That’s great, but now we need those parts. For compounds, it’s pretty easy, so we’ll start with those.

Compounding is the art of taking two smaller words and creating a larger one from them. (And it is indeed an art; look at German if you don’t believe me.) This new word is somehow related to its parts, but how depends a lot on the language. It can be nothing more than the sum of its parts, as in “input-output”. Or the compound may express a subset of one part, like “cellphone”.

Which words can be compounded also changes from language to language. Putting two nouns together (“railroad”) is very common; which one goes first depends, and it’s not always as simple as head-first or head-final. Combinations of two verbs are rarer in Western languages, though colloquial English has phrasal compounds like “go get” and “come see”. Adjective-noun compounds are everywhere in English: “redbird”, “loudspeaker”, and so on.

Verbs and nouns can fit together, too, as they often do in English and related languages. “Breakfast” and “touchscreen” are good examples. Usually, these words combine a verb and an object into a new noun, but not always. Instrumental compounds can also be formed, where the noun is the cause or means of the action. In English, these are distinguished by being noun-verb compounds: “finger-pointing”, “screen-looking”. They start out as gerunds (hence the -ing), but its trivially easy to turn them into verbs.

Really, any words can be compounded. “Livestreaming” is an adjective-verb compound. “Aboveboard” combines a preposition and a noun. The possibilities are endless, and linguistic prescription can’t stop the creative spirit. You don’t even have to use the whole word these days. “Simulcast”, “blog”, and the hideous “staycation” are all examples of “blended” compounds.

All the rest

Compounds are all made from words or, more technically, free morphemes. Most of the other derivational processes work by attaching bound morphemes to a root. Some of these are highly productive, able to make a new word out of just about anything. Others are more restricted, like the rare examples of English reduplication.

Changing class

Most derivations of this type change some part of a word’s nature, shifting it from one category to another. English, as we know, is full of these, and its collection makes a good, exhaustive list for a conlanger. We’ve got -ness (adjective to noun), -al (noun to adjective), -fy (noun to verb), -ize (adjective to verb), -able (verb to adjective), and -ly (adjective to adverb), just to name a few. Two special ones of note are -er, which changes a verb to an agent noun, and its patient counterpart -ee.

In general, a language with a heavy focus on derivation (especially agglutinative languages) will have lots of these. One for each possible pair isn’t out of the question. Sometimes, you’ll be able to stack them, as in words like “villification” (noun to verb and back to noun) or “internationalization” (noun to adjective to verb to noun!).

Changing meaning

Those derivations that don’t alter a lexical category will instead change the meaning of the root. We’ve got a lot of options here, and English seems happy to use every single one of them. But we’ll look at just a few of them here. Most, it must be said, were borrowed from Latin or Greek, starting a couple hundred years ago; these classical languages placed a much heavier emphasis on agglutination than English at the time.

Negation is common, particularly for verbs and adjectives. In English, for example, we’ve got un-, non-, in-, dis-, de-, and a-, among others. For nouns, it’s usually more of an antonym than a negation: anti-.

Diminutives show up in a lot of languages, where they indicate “smallness” or “closeness” of some sort. Spanish, for instance, has the diminutive suffix -ito (feminine form -ita). English, on the other hand, doesn’t have a good “general” diminutive. We’ve got -ish for adjectives (“largish”) and -y for some nouns (“daddy”), but nothing totally regular. By a kind of linguistic analogy, diminutives often have high, front vowels in them.

Augmentatives are the opposite: they connote greatness in size or stature. Prefixes like over-, mega-, and super- might be considered augmentatives, and they’re starting to become more productive in modern English. By the same logic as above, augmentatives tend to use back, low vowels.

Most of the others are concerned with verbal aspect, noun location, and the like. In a sense, they replace adverbs or prepositions. Re-, for example, stands in for “again”, as pre- does for “before”. And then there are the outliers, mostly borrowed from classical languages. -ology and -onomy are good examples of this.

Non-English

We’ve heavily focused on English so far, and that’s for good reason: I know English, you know English, and it has a rich tradition of derivation. Other languages work their own ways. The Germanic family likes its compounding. Greek and Latin had tons of affixes you could attach to a word. Many languages of Asia, Africa, and the Pacific have very productive reduplication. Although I used English examples above, that’s no reason to slavishly follow that particular language when constructing your own.

In the next two posts, we’ll see how Isian and Ardari make new words. Each will have its own “style” of derivation, but the results will be the same: near-infinite possibilities.

Languages I love

A while back, I talked about the four programming languages I hate. Now, you get the contrast: the languages I love. Just by comparing this list to the last one, you’ll probably get a good idea of how I think, but I don’t mind. It’s my opinion. No matter how much justification I give, it’ll never be anything more. Of course, that also means that I can’t possibly be wrong, so don’t bother telling me that I am.

C++

C++ is almost universally reviled, it seems. I’m in the minority on this one, but I’m not ashamed. C++, especially the “modern” C++ that we got in 2011, is one of my favorite languages. It’s fast (running, not compiling), versatile, and ubiquitous. It really is the everything language. To some, that’s its biggest flaw, but I find it to be its greatest strength.

I don’t like languages that force me to think a certain way. That’s part of the grudge I have against Java, and it’s most of the reason I put Haskell on the “hate” list. I’d rather have a language smart enough to say, “Hey, you know what you’re doing. Use this if you need it, but if you don’t want to, that’s cool.”

C++ is like that. Want to write an imperative program? No problem. Like your functional programming instead? Every release this decade has only added FP tools. Object-oriented? It’s still around. C++ is called a multi-paradigm language, and it truly deserves that title.

It’s not a perfect language by any means. Most of the problems stem from the necessary backwards-compatibility with C, but everyone knows (or should know) not to use those bits unless absolutely necessary. And they’re increasingly unnecessary. We don’t have to deal with raw pointers anymore. Nobody should ever be calling malloc or creating static arrays (of the int a[42] kind) in modern C++.

Every programming language is a compromise, but I think the good far outweighs the bad in C++. It was a close thing last decade, but now it’s no contest. Smart pointers, templates, RAII, constexpr, C++ just has too many good features. If we could drop the C stuff and get some better string handling, we might just have the perfect language.

Haxe

I’ve written about Haxe before, but I’ll reiterate some of the things I said.

Haxe basically started out as a better ActionScript, but it’s so much more, and it’s one of those languages I wish was better known. Pay attention, language makers, because this is how you do strongly-typed. It’s also got functional stuff if you want it, OOP if that’s your preference, and a little bit of generic programming. It’s not quite as multi-paradigm as C++, but it’s far better than most.

The main flaw with Haxe is probably its not-quite-what-you’d-expect idea of “cross-platform”. Haxe has a compiler, but no way to make native binaries by itself. You can get C++ output, and Haxe can start up GCC or Clang for you, but that’s the best you ‘re going to get. Beyond that, the library support is lacking, and the documentation could use some work. The language itself, though, is solid.

This is a language I want to use. It’s just hard to come up with a reason I should. Maybe, if Haxe gets more popular, people will stop seeing it as “ActionScript++” and see it for what it is: one of the most interesting programming languages around.

Scala

Put simply, Scala is what Java should be.

Internally, it’s a horrible mess, I’ll grant. I’ve seen some of the “internal” and “private” APIs, and they only serve to make my head hurt. But the outer layer, the one we coders actually use, is just fine. Scala gives you functional when you want it, OOP or imperative when you don’t. It lets you do the “your variable is really a constant” thing that FP guys love so much. (I personally don’t understand that, but whatever.) But it doesn’t force you into anything. It’s multi-paradigm and, more importantly, trusting. Exactly what I want from a programming language.

Scala is where I first learned about pattern matching and actors. That makes sense, as those are two of its biggest strengths, and they aren’t things that show up in too many other languages…at least not the ones people actually use. But they’re not all. Where it can, Scala gives you back the things Java took away, like operator overloading. Yet it’s still compatible with Java libraries, and it still runs on the JVM. (Supposedly, you can even use it on Android, but I’ve never managed to get that to work for anything more complex than “Hello, World!”)

If Java is old-school C, Scala is modern C++. That’s the way I see it. Given the choice, I’d rather use it than plain Java any day of the week. Except for speed, it’s better in almost every way. It may not be the best language out there—it does have its flaws—but it’s one of the best options if you’re in the Java “ecosystem”.

The field

I don’t love every language I come across, nor do I hate all the ones that aren’t listed above. Here are some of the ones that didn’t make either cut:

  • Python: I really like Python, but I can’t love it, for two reasons. One, it has many of the same problems as Ruby regarding speed and parallelism. Two, the version split. Python 3 has some good features, but it’s a total break with Python 2, and it has a couple of design decisions that I simply do not agree with. (Changing print from statement to function is only a symptom, not the whole problem.)

  • Perl: I find Perl fascinating…from a distance. It’s the ultimate in linguistic anarchy. But that comes with a hefty price in both execution speed and legibility. Modern Perl 5 doesn’t look as much like line noise as the older stuff, but it’s definitely not like much else. And the less said about Perl 6, the better.

  • JavaScript: You could say I have a love/hate relationship with JavaScript. It has a few severe flaws (this handling, for instance), but there’s a solid core in there. Remember how I said that C++’s good outweighs its bad? With JS, it’s almost a perfect balance.

  • Lisp: Specifically, that means Clojure here, as that’s the only one I’ve ever really tried. Lisp has some great ideas, but somebody forgot to add in the syntax. It’s too easy to get dizzy looking at all the parentheses, and editors can only do so much.

  • C: As much as I blame C for C++’s faults, I don’t hate it. Yeah, it’s horrible from a security and safety standpoint, but it’s fast and low-level. Sometimes, that’s all you need. And we wouldn’t have the great languages we have today if not for C. Can you imagine a world dominated by Pascal clones?

  • C#: I don’t hate C#. I hate the company that developed it, but the language itself is okay. It’s a better Java that isn’t anywhere near as compatible. Too much of it depends on Microsoft stuff for me to love it, but it fixes Java enough that I can’t hate it. So it falls in the middle, through no fault of its own.

Magic and tech: weapons

It’s a given that, no matter what the setting, many people will want to know the available methods for hurting someone. In RPGs (whether video games or old-school pen and paper), that’s especially true, since combat is such a major part of the most popular role-playing games. Even written works require conflict, and military conflict is the easiest and most familiar form.

Weapons go back almost as far as humanity itself. Any culture can make spears and knives, even before the advent of metalworking. (And don’t neglect those older materials. Mayan obsidian blades could be sharper than any contemporary European sword.) Bows, bolas, blowpipes, and a hundred other “ancient” weapons can be used in a perfectly mundane world, and there’s no reason why they wouldn’t also exist in our magical realm. But they won’t be the only options…

The true path

Not everybody used swords. I know that’s a common trope in fantasy, but it’s just not accurate. Swords were expensive, requiring skilled craftsmanship, quality materials, and more than a bit of time. It might be feasible for a company of 100 men to all be armed with swords, but not an entire army.

Spears are a good alternative. They’re cheap—nothing more than a point on a pole. Unlike swords, which you needed at least some training to use (“Stick ’em with the pointy end” only gets you so far), spears are user-friendly. And, in a pinch, a pitchfork or spade can fill in. Something like a spear would form the backbone of a mundane army. There would be swordsmen, of course, but they’re more likely to be officers or other leaders.

Most other melee weapons are situational. Pikes are great against cavalry, for example, but cumbersome when fighting foot soldiers. Axes, polearms, and all the other nifty items in your favorite RPG’s weapons section have their own ups and downs. They’ll have their uses, but they won’t be widespread. However, armies of this era were anything but regular. Even trained forces could end up using weapons they weren’t overly familiar with, and the peasant rabble might turn up with whatever they could find.

On the ranged side, things aren’t much better. Bows are ubiquitous, particularly in medieval Europe. (English longbows, as we know, were a game-changer.) Crossbows are another option—and they go back a lot further than people think—but they have the problem of being slower and more complex. Other choices, like slings, have situations where they’re useful; a bit of thought should help you come up with something.

And don’t forget artillery. The catapult, trebuchet, scorpion, onager, and so on all have a long history. Every single one of them has been wholly obsolete since the first cannon, but most fantasy is set slightly before the invention of gunpowder, so they’re all you’ve got. Some are siege weapons, intended to wreak havoc on a walled city, while others are what we would now call anti-personnel weaponry.

And the other side

With magic, more efficient and deadly means of attack are possible. We’ve already decided that there aren’t mages running around throwing fireballs, so that’s off the table, but all that means is that the magical weaponry will be more subtle, yet no less devastating.

Magical energy in this setting, as we know from earlier entries in this series, can be converted to force. We’ve used that to great effect to provide motive power, but we know how force scales: F = ma. The same energy that pushes a magical “car” up to a few miles per hour could send a tiny ball of, say, lead, to a seriously high velocity. Who needs gunpowder when magic can do the same thing? That one was almost trivial, and mages worked it out a while back. Now, every regiment has an assortment of what we might consider magic-powered guns. They’re too expensive to be given to every common soldier, but they’ve all but replaced crossbows, and longbows have been relegated to sieges. (Unlike the real world, where cannons mostly came first, the rules of magic mean that handguns are much easier to make.)

But it doesn’t stop there. Magic helps with humble bladed weapons, by means of sharpening and endurance enchantments. Artillery gets an extra oomph from magical power, but its true value there lies in shot varieties. Burning and smoke are a cinch for the greenest of mages; in a catapult, the effect is better than any boiling oil or barrel of pitch. And, of course, any soldier can benefit from a stamina boost.

What does all this do to the battlefields of our magical setting? For the full answer, we’ll have to wait and see the other aspects of fighting, such as defenses. We can say quite a bit now, though. In general, our magical kingdom’s battles will tend to resemble those of a couple hundred years later. Think more Late Renaissance than High Middle Ages, except without the cannons.

Not everyone has guns, so the largest part of the fighting will still be hand-to-hand, with swords and spears and all the rest. In place of a contingent of archers will be magical gunners, armed with ever more powerful dealers of death. They won’t match today’s high-powered rifles, but they wouldn’t be out of place in the American Revolution, in terms of their effect on the enemy.

Artillery will look more medieval, but there are a few differences. With magic replacing the…ancillary supplies for shot, artillery forces will be a bit less exposed. That means they’ll be free to take more risks, to advance more quickly. Oddly enough, they won’t be as much use in a siege, at least until they get right up to the gates. Circumstances converge to make artillery very good at distance (because it’ll still out-range anything else) and up close (because it can do the most damage), but not so great in the middle.

Other uses

As we know, weaponry isn’t limited to the battlefield. Personal weapons are a feature of any culture, as are the rules governing them. For everything except the magic-powered guns, little will change in this regard. Openly carrying a weapon is still a symbol of ill intent, drawing it more so. Hidden weapons will be harder to find, because they can be smaller or disguised as something innocuous, but mages can point out magical items.

Assassination is easier in the magical kingdom. That’s unfortunate, but not unexpected. With the greater power available, not everyone will see the need for greater responsibility. It’s almost self-balancing, since everyone knows how easy it is, sort of like Mutually Assured Destruction. Blood feuds can erupt into a war in the streets, but that’s not too different from the real world of that time.

The original use for many weapons was killing animals, and this is only helped by magic. Ask any hunter: guns are far better than bows. That’ll be true even when the bullets are powered by the invisible force of magical energy. (This could have environmental issues—hunting to extinction is much easier—but that can wait for a later post.)

All told, adding magic to weaponry has nearly the same effects as adding gunpowder. The world becomes more dangerous, but many new possibilities appear. New avenues of research open up. To fight the growing offense, the mages will be asked to create new defenses. And that will be the subject of the next post in the series: how to protect oneself.

E-zi script, an emoji syllabary

The other day, Twitter announced it would retain its 140-character limit for posts. A hundred and forty letters, spaces, and numerals isn’t all that much, if you think about it. In fact, this paragraph is already far too long to fit in a single tweet.

Speakers of other languages which use other scripts sometimes have it easier. Twitter’s limit applies to characters, not bytes, and all of Unicode is available for use. If you’re writing in Chinese, for example, you can fit a lot more information into 140 characters. That’s because Chinese is a logographic writing system, not an alphabet like ours. There are thousands of symbols, most of them representing part, if not all, of a word. But Chinese writing is hard to learn, especially for Westerners. To make matters worse, we Americans don’t have an easy way to input characters of foreign languages. (A lot of Chinese-made phones do, but that doesn’t help unless you know how to do it.)

What many Americans do have, however, is another input method: emoji. All told, there are about a thousand of the little symbols, representing everything from emotions to animals to food. Why not use those for a script?

E-zi

Enter E-zi, the emoji syllabary. E-zi is a set of rules and conventions to turn English text into a string of symbols—emoji, but also letters, numbers, and the graphical symbols available on all keyboards—that are easily inputted. Due to the nature of the English language, we can’t quite achieve the efficiency of Chinese or Japanese writing, but we can do better than plain text.

To get a taste of how E-zi works, here’s a sample. The text is the first article of the Universal Declaration of Human Rights:

All human beings are born free and equal in dignity and rights. They are endowed with reason and conscience and should act towards one another in a spirit of brotherhood.

In E-zi, this comes out as:

◻ 👤 Bns R 🐗📯 🆓 & = N 💫🔫🔼🍵 & 👉s. 👫 R N🔽d + ♻🌞 & 🚧🔀ns & 👞🔽 🎬 ▶ 1 A🔘* N A 👻 O 🔆🔘*❓d.

By my count, we’ve dropped from about 170 characters to 81. Many of those are spaces, however, and some can be removed without any loss of understanding. A lot of people do that already in cramped conditions like Twitter, with abbreviations like “txt”. This is just taking it a few steps further.

Reading emoji

The core of the E-zi system is in the way emoji are read. By and large, this must be learned, unfortunately, but the basic ideas are pretty simple.

First, every non-alphanumeric symbol can be read in two types of ways. Take ◻, for example, the first icon we used. When written as its own word, it should be read as “all” or “always”. Another symbol, 🔴, similarly indicates the word “red”, and 🔎 is “detail”.

When combined with other symbols (including letters and numbers), these are instead considered to be syllables or sounds. A given symbol can have lots of these syllabic or phonetic readings, but most are easily derived from the lexical form. For example, ◻ has a syllabic reading AHL (I’ll explain this notation later); 🔴 can be R, RE, or RED, with the last two being most common; and 🔎 reads as DEE or the rarer DEET. Put them together as the E-zi “word” ◻🔴🔎: AHL-RE(D)-DEE, or “already”.

This rebus principle is the heart of E-zi. Words are built as groups of sounds, with a large amount of leeway in which sounds can combine. A good illustration of this is the string I used to translate “dignity”: 💫🔫🔼🍵 . This consists of four symbols, as you can see. The first, 💫, is read DI. 🔫, obviously, is “gun” or, in our phonetic notation, GUHN. The little 🔼 indicates a schwa sound, noted as UH. Finally, 🍵 is, well, “tea”. It’s not a perfect match for the English pronunciation of “dignity”, but it comes close enough that we understand what’s meant.

If we would like a lexical reading where we’d normally have a syllabic one, or vice versa, we can use the * symbol after a symbol. We did that in our quote above, with A🔘* “another”.

Plain letters

In the cases where there isn’t an appropriate symbol, we can resort to letters. But it’s a waste to have two sets of the same thing, upper and lower case, so E-zi repurposes the capital letters. Each one stands for a simple word, usually grammatical in nature:

Letter Translation
A a/an
B be (or “is”, etc.)
C can
D do
E e- (electronic)
F from
G go
H has/have
I I
J just
K okay
L will (future tense)
M me
N in
O of
P part
Q question, cue, or queue
R are
S is
T the
U you
V very
W what
X ex-, or the word “ex”
Y why
Z as

Lower-case letters, on the other hand, are absolutely necessary. They can be placed anywhere, and they mostly sound like their English equivalents. You’d also use them to spell out names and other words where the actual letters used are important. A few, however, also have special meaning when placed at the end of a symbolic word. These are based on a very simplified English grammar:

  • “s” creates a plural form of any word: 🚗 “car”; 🚗s “cars”. This is always regular, so no need to worry about convoluted English plurals like “oxen”.
  • “d” forms the past tense of a verb: one reading of ⚔ is “fight”, so ⚔d can be read “fought”. Again, totally regular.
  • “n” makes a verb into a participle form. Using the same example, ⚔n should be read “fighting”. Similarly, Gn is “going”.

These can all be combined. In the larger text, we had Bns for “beings”. It might look odd in the middle of all the symbols, but it works just the same.

Other symbols

E-zi also makes use of the other keys on your keyboard. Numbers work a bit like capital letters, in that they stand for full words—namely, their values. In other words, 1 is to be read as “one”, and so on. You can use the rebus principle to play with these (4m for “form”, ↩8 for “late”), but numbers have no syllabic or phonetic readings.

Most punctuation marks are used like in English. These include the period, comma, question mark, exclamation mark, semicolon, and colon. Quotation marks are, of course, used to mark quoted speech. The apostrophe, on the other hand, is reused as a general possessive suffix: M’ is “my”, T👨’ is “the man’s”, etc. Like “s” and the others, this ignores traditional English sensibilities in favor of logical regularity.

The other symbols are mainly those on the top row of your computer’s keyboard. The number sign # is reserved for use in hashtags, and the caret ^ indicates a signature. The others can be used as symbols:

Symbol Name Use
$ dollar sign dollar, money
% percent sign percent
& ampersand and
+ plus sign and, with
– hyphen-minus without
/ solidus and/or
= equals sign is, equals
@ commercial at at
| vertical bar or (choices)
~ tilde negation, not

Most of these are lexical-only, but &, +, @, | , and ~ work as syllables, too.

Finally, the grave accent ` marks off text as “regular”, i.e., not E-zi script. You use it in pairs, like quotation marks. The other “grouping” symbols, like brackets and parentheses, are reserved for future use.

Special groups

There are two special groups of Unicode symbols that E-zi gives special meaning to. The clock faces are a set of 24 symbols displaying times in half-hour increments. In E-zi, these simply indicate those times, with no other reading possible. For instance, 🕥 means the time 10:30 and nothing else.

Another group is called the “regional indicator symbols” by Unicode. These are the letters A-Z in boxes, but they are considered the preferred way of marking countries. E-zi uses them in this way, always in pairs representing a country code. (In some places, this may cause them to be displayed as a national flag instead. E-zi takes that as a feature.) Thus, since the country code for the United States is US, the E-zi sequence 🇺🇸 can be read as “United States”. In addition, the emoji 👤 can be suffixed to create an abbreviated form representing a nationality: 🇺🇸👤 should be understood as “American”.

All other symbols are unused by E-zi. The “cat faces” such as 😸 are reserved for expansion, while the skin color modifiers (“Fitzpatrick modifiers”) are ignored.

Phonetic notation

English is a notoriously difficult language to pronounce, even before you worry about dialectal differences. Thus, I’m using a phonetic notation to record E-zi syllabic readings. Nothing’s perfect, but as long as we’re in the ballpark, communication will work.

Most consonants in the notation should be read as their IPA values. This means that K is preferred to C, KW instead of QU, and so on, so some words will look odd. A few, though, have to be changed:

Phoneme Symbol Example
θ TH THIN “thin”
ð DH DHIN “then”
tʃ CH CHEK “check”
dʒ J JEL “gel”
ʃ SH NAYSHUHN “nation”
ʒ ZH PLEZHUHR “pleasure”
j Y YOOZ “use”
ŋ NG SONG “song”

Fortunately, I’ve taken the liberty of dismissing a few of the more common dialectal problems. Final “r” is assumed to always be there; it’s an America-centric view, but it makes things easier. It doesn’t mean you have to pronounce it, though. The “wh” sound, on the other hand, is merged with plain “w”, meaning “what” and “watt” are both WAHT. That was hard for me to do, as I still have a separate “wh” sound, but I realize I’m in the minority. Other dialectal sounds are also ignored; you’ll have to find their closest “standard” equivalents.

Vowels are even more problematic. I’ve taken the Wells lexical set and assigned a sequence of letters to each vowel sound in it. That gives us something reasonable to work with, although it can look a little strange at first. Don’t worry if some of these vowels sound the same in your dialect; that just means you have more opportunities for word play.

Phoneme Keyword Symbol
ɪ KIT I
ɛ DRESS E
æ TRAP A
ɔ LOT O
ʌ STRUT UH
ʊ FOOT U
ər NURSE UR
i FLEECE EE
eɪ FACE AY
ɑ PALM AH
ɔ THOUGHT O
o GOAT OH
u GOOSE OO
aɪ PRIDE IY
ɔɪ CHOICE OI
æʊ MOUTH OW
ɪr NEAR EER
ɛr SQUARE AIR
ar START AR
ɔr NORTH OR
or FORCE OR
ʊr CURE OUR
ər LETTER UR
ə COMMA UH

The big list

By my count, there are 970 emoji that have both lexical and syllabic readings. That’s way too many to list here, so I’ll just link a PDF chart that you can view at your leisure. Note that it’s sorted primarily by the least complex syllabic reading. My organization skills do leave something to be desired, however.

E-zi script v0.4

Conclusion

I hope E-zi is a fun and interesting way to make your short-form text more descriptive, more efficient, and more alive. Sure, I could have gone and made something with no relation to English whatsoever, but this way is much easier. Not only that, but it’s a method that stands the test of time. The basic principles of E-zi are the same used in Chinese script, Egyptian hieroglyphs, and Sumerian cuneiform, the oldest writing systems we know. In our modern world, however, we have new reasons to want the succinctness of syllabic and logographic script. Thus, unlike these others, E-zi is made with today’s needs in mind. It’s a twenty-first century take on a millennia-old idea.

All of E-zi is free for you to use however you see fit. No charge, no strings attached. So, have fun with it, and let me know if you use it!

The problem with emoji

Emoji are everywhere these days. Those little icons like 📱 and 😁 show up on our phones, in our browsers, even on TV. In a way, they’re great. They give us a concise way to express some fairly deep concepts. Emotions are hard to sum up in words. “I’m crying tears of joy” is so much longer than 😂, especially if you’re limited to 140 characters of text.

From the programmer’s point of view, however, emoji can rightfully be considered a pox on our house. This is for a few reasons, so let’s look at each of them in turn. In general, these are in order from the most important and problematic to the least.

  1. Emoji are Unicode characters. Yes, you can treat them as text if you’re using them, but we programmers have to make a special effort to properly support Unicode. Sure, some languages say they do it automatically, but deeper investigation shows the hollowness of such statements. Plain ASCII doesn’t even have room for all the accented letters used by the Latin alphabet, so we need Unicode, but that doesn’t mean it’s easy to work with.

  2. Emoji are on a higher plane. The Unicode character set is divided into planes. The first 65,536 code points are the Basic Multilingual Plane (BMP), running from 0x0000 to 0xFFFF. Each further plane is considered supplemental, and many emoji fall in the second plane, with code points around 0x1F000. At first glance, the only problem seems to be an additional byte required to represent each emoji, but…

  3. UCS-2 sucks. UCS-2 is the fixed-width predecessor to UTF-16. It’s obsolete precisely because it can’t handle higher planes, but we still haven’t rid ourselves of it. JavaScript, among others, essentially uses UCS-2 strings, and this is a very bad thing for emoji. They have to be encoded as a surrogate pair, using two otherwise-invalid code points in the BMP. It breaks finding the length of a string. It breaks string indexing. It even breaks simple parsing, because…

  4. Regular expressions can’t handle emoji. At least in present-day JavaScript, they can’t. And that’s the most used language on the web. It’s the front-end language of the here and now. But the JS regex works in UCS-2, which means it doesn’t understand higher-plane characters. (This is getting fixed, and there are libraries out there to help mitigate the problem, but we’re still not to the point where we can count on full support.)

  5. Emoji are hard to type. This applies mostly to desktops. Yeah, people still use those, myself included. For us, typing emoji is a complicated process. Worse, it doesn’t work everywhere. I’m on Linux, and my graphical applications are split between those using GTK+ and those using Qt. The GTK+ ones allow me to type any Unicode character by pressing Ctrl+Shift+U and then the hexadecimal code point. For example, 😂 has code point 0x1F602, so I typed Ctrl+Shift+U, then 1f602, then a space to actually insert the character. Qt-based apps, on the other hand, don’t let me do this; in an impressive display of finger-pointing, Qt, KDE, and X all put the responsibility for Unicode handling on each other.

So, yeah, emoji are a great invention for communication. But, speaking as a programmer, I can’t stand working with them. Maybe that’ll change one day. We’ll have to wait and see.

The future of government

This year of 2016 is, in the US, an election year. For weeks we’ve been mired in the political process, and we’ve had to suffer through endless debating and punditry. The end isn’t near, either. We’ve got to endure this all the way to November.

It’s impossible to not think about government right now. As a builder of worlds and settings, I’m naturally drawn to the idea of government as a concept, rather than as its concrete implementation today. Churchill is usually quoted as saying that democracy is the worst form of government, apart from all others that have been tried. We know what others have been tried: republic, monarchy, communism, theocracy, and so on. Looking at the list, maybe it’s true.

What about the future, though? We’re in the midst of a technological revolution that shows little sign of stopping, yet it seems that little of that has paid off in the political sphere. (If you look at some of the computerized voting systems in use today, you might even think we’ve regressed!) But that could be a transitional thing. In the far future, when we of humanity have moved outward, to the rest of the Solar System and beyond, what will government look like then?

Status quo

It’s easy to think that the way things are is the way they will forever be. Conservatism is a natural thing, because it’s the path of least resistance. And in the near-term, it’s the most likely outcome. Barring some major upheaval, the US will remain a federal republic, China an authoritarian, communist regime, and most of the Middle East an anarchic disaster.

There will be a few slight changes, for sure. The Commonwealth nations are always talking about dissolving the monarchy; it’s reasonable to assume that, one day, talk will beget action. The same with most of the other Western monarchies remaining. As jobs are increasingly given over to robots, socialist tendencies will only increase, as they are doing right now in Europe. Something will eventually bring stability to Iraq and Syria. (Okay, that last one is awfully far-fetched.)

But the advance of technology will open up new avenues of government. And if we do manage self-sustaining colonies beyond Earth, then “self-sustaining” may eventually become “self-governing”. A well-settled Solar System means ample opportunity for new nations to spring up, a breeding ground for new experiments in government. So what might those look like?

Direct democracy

One possibility that isn’t that hard to imagine is direct democracy. As opposed to a democratic republic—like most democracies today—a direct democracy dispenses with the elected officers. It is literally of, by, and for the people. Everybody gets to vote. On everything. (Within reason, of course.)

We can’t really do this today on anything higher than a local level, because nobody would have time for anything else! But a few special situations can arise that would make it palatable. Small colonies are the obvious place for a direct democracy; they work just like towns. A very well-connected and well-educated society could bring direct democracy to a larger populace, but likely only on a limited scale. Mundane things might be left to the elected, while serious matters are voted on by the public at large.

The chief downside to direct democracy is that it relies on the knowledge and wisdom of the masses. It requires faith in humanity, not to make the right decision, but only to make an informed one. And, as I said, it’s also too easy to overload the populace. Partisan voting seems like a major trap here, if only because choosing a party is easier than voting on each individual issue.

Techno-socialism

By 2020, a mere four years away, millions of people will have lost their jobs to robots, and it’ll only go downhill from there. A few decades out, and half the world’s population will be looking for work in the ever-fewer fields left to living humans. There are some things computers can’t do, but not everybody has the skills necessary for them.

One solution to this looming employment crunch is already being tested in parts of Europe: the universal basic income. It’s nothing more than a monthly stipend, a kind of all-encompassing unemployment/welfare check. Combine this with the possibility of technology ending the “demand economy”, and you have the makings of a true socialist state: a planned government and economy designed to create and uphold a welfare state. Most people would live on the basic income, with their needs met by government-provided facilities, while those who can have jobs are a cut above, but there’s always the chance of moving up in the world.

This one’s big flaw is human nature. We’re greedy, and we don’t really trust other people to know what’s best for us. This kind of techno-socialism doesn’t remove either need or want, but leaves it in the hands of a (hopefully) benevolent government, and it easily falls prey to a pigeonholing “everyone’s the same” mentality. For the “have-nots”, basic income is enough to provide for, well, basic needs, but not much else. The “haves” would be able to get more in the way of amenities, but the high taxes they would have to pay to provide the public services are definitely a turn-off.

AI autocrats

If you believe the AI singularity folks, advanced artificial intelligence isn’t that far away. The day it surpasses human ingenuity might even be within our lifetimes. It’s only natural to put faith in a higher power, and the AIs might become higher powers, relative to us.

There’s two ways this could go: computer-controlled utopia or tyrannical killbots. Those, however, are two sides of the same coin. Either way, its the AI in charge, not us. If artificial intelligence reaches a point where we can no longer understand it, then we won’t know what it’s thinking. At that point, it’s almost like a “direct” theocracy.

We might willingly put ourselves in such a situation, though. How alluring would it be, the idea of handing control to somebody, something else? You don’t have to worry about anything anymore, because The Computer Is Your Friend.

An AI-controlled society all but leads itself to being planned to the point of ruthless efficiency. It might even work out like an extreme version of the techno-socialism above, except that an even smaller fraction of the populace is gainfully employed.

Corporate oligarchy

Corporations already control most governments from behind the scenes. At some point in the future, they might come out of the shadows. If land rights in space are granted to private firms—under the Outer Space Treaty, they can’t be claimed by nations—then we may see a revival of the old “company town” idea. You work for the Company, you live in its houses, you buy its food, and so on. They’re in control, but you can always end up as one of the shareholders, or make your own corporation.

In practice, this form of government isn’t all that exciting. It boils down to a kind of neo-feudalism where the corporations are the lords and their employees are the serfs…with one exception. Corporations try to maximize profits. If they’re allowed to openly run the show, that will be the number one goal for everybody.

This kind of oligarchy can work, especially if you’re one of the higher-ups, but it’s not without its faults. All those people need to be employed somehow, not to mention fed, clothed, educated, and protected. The ideal corporatist system would have all those needs met by private industry, of course, but automation means there’s only so much work left to be done. Still, for a small society, it might work.

Other possibilities

The imagination can run wild here. The only limits are in the mind. But people are going to be people—unless they’re transhumans and cyborgs—and human nature is one of the strongest forces we know. Most importantly, we won’t change overnight. There will be transition periods, no matter what form of government we eventually reach. There’s even the chance that, given some sort of apocalyptic event, we’ll revert to the tried and true methods of the past. A town in the middle of a disaster will, by necessity, be authoritarian, even dictatorial. With years of peace, though, new ideas can find their footing. With time and space, they may even have their moment in the sun.

Sound changes: everything else

Not every sound change works on just consonants or just vowels. Some can transmute one into the other. Others affect entire syllables or words. A few work on a different level entirely. So, we’ll finish this series by looking at these “miscellaneous” types of evolution.

Tones

Tones have to come from somewhere. One of the ways they can appear (tonogenesis) is through the loss of consonants preceding or following a vowel. A voiced consonant, for instance, can cause the vowel after it to be spoken at a lower pitch. If those consonant go away, the change in pitch can remain: a low tone. As another example, a number of consonant elisions led to the tonal system of Chinese, along with its restrictive syllable structure.

Once a language has tone, it becomes a target for evolution. Tones can change, merge, split, and disappear, exactly as phonemes. Unstressed syllables may develop a neutral tone, which might get reanalyzed as one of the existing tones. Sequences of tones can affect each other, as well, a complex process called tone sandhi.

Like any other part of language, tone is subject to the same forces that drive all sound change, which can be summed up as human laziness. More on that later.

Sandhi

The term sandhi comes from Sanskrit; roughly speaking, it means “joining”. In modern linguistics, it’s a catch-all term used for any kind of sound change that crosses the boundary between morphemes. The “linking” R in some English dialects is a kind of sandhi, and so is the use of the article “an” before vowels. Romance languages show a couple more instances of the process: Spanish de el → del; Italian della → dell’; the heavy use of liaison in French.

When sandhi becomes systematic, it can create new words, like Spanish del and al. These, of course, can then be changed by any other sound change. And it’s not limited to vowels. Consonants can also be affected by sandhi. The most common expression of this is anticipatory voicing across word boundaries, but other types of assimilation are equally valid.

Epenthesis

Epenthesis is the adding of a sound, the opposite of elision. It’s another way of breaking up a cluster that violates a language’s phonological rules or aesthetic sensibilities. Some epenthesis is a kind of sandhi, like English “an”, and the diaresis discussed last week is another form. Those aren’t the only possibilities, though.

An epenthetic vowel can be inserted between two consonants, and this will usually be a neutral vowel, whatever the language considers that to be. Schwa (/ə/) is a common choice, but /e/, /a/, and /o/ also pop up. /i/ and /u/, however, are usually too strong.

Similarly, strings of vowels may be broken up by epenthetic consonants. Again, something weak and unassuming is needed, something like /r/, /n/, /l/, /h/, or /ʔ/. /w/ and /j/ can be used as glides, as we have seen, but they’ll tend to be used only when they can relate to one of the vowels.

Another option for consonant clusters is an epenthetic consonant, one that bridges the gap between the two. Greek, for example, shows a sound change /mr/ → /mbr/, as seen in words like “ambrosia”. Many speakers of English insert epenthetic consonants like this all over, without even knowing it, like the [p] in “something”. (If this became phonemic, it would be essentially the same thing that happened to Greek.)

Haplology

Two syllables that are fairly close in sound may not stay together for very long. Haplology is a sound change that involves the deletion of one syllable of such a pair. It can be either one, and there’s no standard for how “close” two syllables need to be to trigger the change. English examples include the common pronunciations of “probably” and “February”, and others aren’t hard to find. (In another one of those linguistic oddities, “haplology” itself can fall victim to this, becoming “haplogy”.)

Applying the rules

Although there are plenty of other sound changes out there—again, I refer you to Index Diachronica for more—we have gathered enough over the last three posts to start looking at how to apply them to a conlang. There are plenty of programs out there that can do this for you, but it helps to know the rules. These aren’t set in stone, mind you, but you should have a good reason for breaking them. (That reason would probably lead to more conlanging, so I’m not complaining.)

First, evolutionary sound changes are regular. They’ll almost always happen when the right conditions are met. If you’ve got devoicing of final stops, as in German, then essentially every final stop is going to get devoiced. Sure, there may be exceptions, but those exceptions can be explained. Maybe those words appeared in their current forms after the sound change.

Second, remember that sound changes don’t care. This is a subset of regularity, but it bears repeating. A sound change will affect a word no matter what that word’s history. A particular evolutionary condition may be met because of an earlier sound change, but later changes won’t know that. They’ll only “see” a word ripe for alteration.

Third, sound changes operate on a lower level. They’re “below” grammar and, as such, aren’t affected by it. But this means that grammatical ambiguity can arise, as when sounds of case endings are merged or dropped. (This one happened in both English and the Romance languages.) Speakers will then need to find ways of clearing things up, leading to innovations on the grammar side of things.

Fourth, sound change stems from laziness, a desire to minimize the effort required in speaking and conveying our thoughts. Weak sounds disappear, dissimilar sounds merge, and it’s all because we, as a whole, know we can get away with it. As long as there’s enough left to get the message across, all else is simply extraneous baggage. And that’s what’s most likely to change.

Finally, evolution is unceasing. When it comes to language, the only constant is change. Even our best efforts at writing and education and language academies can’t stop sound change. There will always be differences in speech. Those will form dialects, and then those may split into new, mutually unintelligible languages.

Software internals: Classes

Whether you use object-oriented programming or not, you’ve most likely encountered the class and the object. You’re probably coding in a language that has or uses both of them. If you’re not (say you’re using C or something), you still might be using the idea of a class and an object. How they actually work depends on the language, library, or framework in question, but the basic implementation isn’t too different from one to the next.

Objects, no matter what kind you’re using, are data structures. Classes are data types. In many languages, both of these work together to make OOP possible. But you can have one without the other. JavaScript, for instance, has objects, but no classes. (ES6’s class is mere syntactic sugar over a prototype-based implementation.) Since that’s more common than the alternative (classes but no objects), we’ll look at objects first, then add in the bits that classes or their replacements provide.

Objects

Objects, from a language-neutral point of view, are made up of a number of different variables usually called fields. They’re a composite kind of data, like C the struct, except that higher-level languages have a lot more support for doing things with them. But that’s all they really are: a bunch of fields.

That already suggests one way of laying out an object in memory: allocate the fields consecutively. For a struct, you don’t need to do anything else except initialize the block of memory. If one of your fields is itself an object, then that’s okay. You can nest them. You have (rather, the compiler has) the knowledge of what goes where, so it’s not a problem.

The above option works fine in a system where objects are static, where their layouts don’t change, only the contents of their fields. Dynamic languages that let you add and remove object fields need a different approach. One that’s commonly used is a map. Basically, field names (as strings or a special, faster “symbol” type) are associated with chunks of data, and the object is nothing more than a collection of name-value pairs. Using hashes and other tricks (that we may visit in a future post), this can be very fast, though never as fast as direct memory access.

Methods

Methods are functions that just happen to have a special binding to a particular type of object. Different object systems define them in different ways, but that core is always the same. When code calls a method, that method “knows” which object it belongs to, even though it was (usually) defined generically.

Python and object-oriented C libraries like GTK+ make this explicit: every method takes an object as its first parameter. JavaScript takes a different tack, adding methods to the prototype object. Most every other case where methods exist, they’re implicitly made such by their definitions. C++, C#, and Java, for instance, simply let you define functions inside the class, and those are the methods for objects of that class. When they’re called, they receive a “hidden” parameter, a reference to the object they’re called on: this.

As functions can contain arbitrary code, we can’t exactly put them in memory with the fields. One, it kills caching, because you might have kilobytes of method code in between fields. Two, some operating systems have protection systems in place to prevent code and data from intermingling, for very good security reasons.

Instead of having the code and data together, we must separate them. But that’s fine. They don’t need to be mixed in together anyway. However methods are defined, they’ll always have some sort of connection to an object—a pointer or reference, in low-level terms—and they can use that to access its fields. Conversely, the structure of an object can contain function pointers that refer to its methods.

Inheritance

We don’t really start getting into object-oriented programming until we add in inheritance. Coincidentally, here’s where the internals start to become more and more complex. Simple single inheritance lets an object take on parts of a parent object. It can use the parent’s methods as if they were its own, as well as some of the fields. Multiple inheritance is the same thing, but with more than one parent; it can get quite hairy, so most common languages don’t allow it.

The methods don’t really care whether they’re operating on a base or derived class, a parent or a child. For static languages, this is because of the way objects using inheritance are laid out in memory. Broadly speaking, the parent object’s fields come first, and those are followed by the child’s fields. As you go further down the inheritance chain, this means you can always backtrack to the root object. Just by doing that, we get a few things for free. A pointer to an object is the same as a pointer to its parent, for example. (GTK+ makes this explicit: objects are structs, and a child object simply lists its parent as its first field. Standard C memory access does the rest. Problem is, you have to use pointers for this to work, otherwise you get slicing, a mistake every C++ programmer knows all too well.)

Dynamic languages don’t get this benefit, but they all but emulate it. Objects might have a hidden field pointing to the parent object, or they may just copy the parent’s map of names and values into their own as their first act. The latter means extra metadata to keep track of which fields were defined where, but the former is slower for every access of an inherited field. It’s a classic size/speed tradeoff; most languages opt for the faster, but slightly more bloated, map-mixing approach.

For multiple inheritance, well, it’s a lot harder. In dynamic languages, it’s not quite as crazy, but the order of inheritance can make a difference. As an example, take a class C that inherits from classes D and E. If both of those have a field named foo, there’s a problem. C can’t have two foos, but the different base classes might use theirs in different ways. (The only modern static language I know that allows multiple inheritance is C++, and I don’t want to try to explain the memory scheme it uses. I’ll leave that to you to find out.)

Polymorphism

What makes object-oriented programming truly object-oriented is polymorphism. Child classes are allowed to effectively redefine the methods they inherit from their parents, customizing them, but the caller neither knows nor cares about this fact. This is used for abstraction, and it’s not immediately obvious how they do it.

Dynamic languages have a map for their methods, as they do for fields. For them, polymorphism is as easy as changing an entry in the map to refer to a different function…if that’s the way they choose to do it. Another option is only keeping track of the methods directly defined by this object, referring access to all others to the parent class, who might pass it up another level, and so on. For a language using single inheritance, this is linear, and not too bad. With multiple inheritance, method resolution becomes a tree walk, and it can get quite intensive.

Static languages can take advantage of the fixed nature of their classes and reduce polymorphism to a table of function pointers. C++ programmers know this as the v-table (or vtbl), so called because polymorphic methods in that language are prefixed with the keyword virtual; hence, “virtual table”. This table is usually kept in memory somewhere close to the rest of the object, and it will contain, at the very least, a function pointer for each polymorphic method. Those that aren’t overriding a method from a parent class don’t have to be listed, but not every language lets you make that decision.

Construction and destruction

An object’s constructor isn’t necessarily a method. That’s because it also has to do the work of allocating memory for the object, setting up any inheritance-related framing (v-tables, prototypes, whatever), and general bookkeeping. Thus, the constructor doesn’t even have to be connected to the class. It could just as easily be a factory-like function. Destructors are the same way. They aren’t specifically methods, but they’re too bound to a class to be considered free functions. They have to deallocate memory, handle resource cleanup, call parent destructors, and so on.

On the lower levels, constructors and destructors aren’t really part of an object. The object can never call them directly in most languages. (In garbage-collected languages, nobody can call a destructor directly!) Therefore, they don’t need to know where they are. The same is generally true for the C++-specific notions of copy and move constructors. The only wrinkle comes in with inheritance in the case of destructors, and then only in C++, where you can have polymorphic methods but not a polymorphic destructor; this is a bad thing, and it’s a newbie mistake.

Next up

I’ll admit that this post felt a lot smoother than the last two. Next time, we’ll look at another data structure that shows up everywhere, the list. Linked lists, doubly-linked lists, list processing, we’ll see it all. As it turns out, there’s not too much to it. Maybe those Lisp guys were onto something…

Building the pantheon

In fantasy worlds, unlike our modern, Western one, monotheism seems to be quite uncommon. Maybe it’s a way to show the “otherness” of the story, or a method of inserting larger-than-life characters into the world in a way that they can interact with the protagonist. Perhaps the intent is to illustrate a “war of ideas” in a metaphorical way. I’m sure you can think of plenty of other reasons, but they all end with the same result: a pantheon.

Now, there are two different concepts at work here. First is the “traditional” polytheism, like the Greeks, Romans, Norse, and Egyptians. In all of these cases—and others from around the world—you have a multitude of gods. They all have their own niches (Aphrodite, goddess of love, for example) and they have a body of lore surrounding them. This is the idea we’ll be exploring in this post. The other is pantheism, which you’d expect to be related to the word pantheon. It’s not; “pantheism” isn’t the belief in multiple gods, but the belief that (roughly speaking) God is everywhere and everything. From a worldbuilding perspective, that doesn’t offer too much, so we’ll stick with polytheism. We can live with the minor etymological confusion.

The pantheon

As usual, the best way to start creating something is to look at similar things that already exist. Most early cultures in history were polytheistic, and a few have left a large amount of mythology. That’s the key to polytheism: the myth. With dozens, hundreds, or even thousands of gods, stories are the way to keep them straight. Stories bring them to life, bring them into the world. They show why these gods should be worshipped…or even how.

Polytheistic gods, unlike the solitary God of monotheistic religions, are, in a very real way, superhuman. They wouldn’t be gods if they didn’t have some sort of supernatural power or ability attributed to them, although heroic humans can be, and often were, deified. (Castor, Imhotep, and Guan Yu are all examples here.) But gods of a pantheon are unlike a single God in another way: they can be flawed. Zeus is well-known as lecherous, while Hera was the personification of jealousy, and Loki would, today, be a troll in the Internet sense. A far cry from the perfect divinity of the Judeo-Christian God.

This humanization of the divine means that gods can be characters in a literary sense. They can have conflict, both with each other and with outside forces. They can walk the mortal world, interact with living people in more than just visions. But they’re still gods. They can just as easily be unseen, nothing more than the intended recipients of prayers and pleas and sacrifices. They can work behind the scenes as easily as on the stage. And if they’re never visible, then you get to pose the interesting question: did they ever truly exist?

Creating the creators

Of course, no matter how you use the pantheon, you’re going to need one. This doesn’t have to be too elaborate. A list of names will suffice, maybe with a note as to the purpose of each one. If you want to go deeper, though, you can.

One question you don’t have to answer is “how many?” The trick with polytheism is that there doesn’t have to be a set number of deities. You can have two, or twenty, or twelve hundred, and it won’t matter much. If you have a small, set number, it’ll be easier to enumerate them all, but you can always leave room for expansion.

In a way, creating a pantheon is dividing up the universe, decomposing it into its fundamental parts. The exact criteria will depend on the culture—a typical medieval fantasy people won’t have a god of computers, for instance—but a few things are near-universal. Remember that the more gods you have, the less each one has to do. With a vast array of deities, you can get into some pretty fine distinctions.

Creator gods are probably everywhere. Naturally, monotheistic faiths only have (exactly) one of these, but polytheism gives you more authorial options. Creators can be distant, aloof of their creation. Alternatively, they might prefer to be up close and personal with their masterpiece. Maybe there are multiple creators, each given a different element; one god created the land, another the sea, for example.

The creation of the world can be extremely interesting in its own right. Perhaps there was a great battle among the gods. Or the world could have been created by more primordial beings, with the gods as their children. Or maybe the world is a song given physical form by the highest of gods, while the others merely inhabit and protect it.

Local gods exist in many pantheons. These are typically small-time guys, possibly deified humans. Ancient, half-legendary rulers or wise men are good candidates. But it’s also possible that the local god is a “spirit” of a place, like the Roman genius loci. Another possibility is a more powerful god who is intimately connected with a city, such as Athena. Any way you look at it, local gods will have the center of their worship in a particular area. Their greatest shrines or temples will be there, and outsiders may not even consider them true gods.

Elemental deities make up another common type. These are your gods of fire and water and weather and the like. In larger pantheons, especially early on, these will form the bulk of the roll of divinity, if only because older cultures, lacking modern technology, had less control over the natural world. Everything that man couldn’t control, almost by definition, the gods could, so one of them would be given an elemental role. Plenty of overlap is possible here; creators can be elemental. Local gods can, too, especially if a type of weather is strongly associated with a certain place, like snow on the highest mountaintop.

Patron deities come to the fore as a polytheistic civilization develops. Eventually, they will begin to outnumber the elemental gods, Patrons can be of a craft (Vulcan and smithing), an act (Ares and war), or just about anything else. Like some theological Rule 34, if people can do something, there will be a patron for it. (We see this even in monotheism, with the Catholic patron saints.) This is a place where the fine divisions of a vast pantheon come into the spotlight. Why have a single god of agriculture, when you can have one for grain, another for fruit, and half a dozen for different kinds of trees? Patrons can be creators, too; art and fertility work well for these. (Why? Because these are both acts of creation.) Local gods, by contrast, are often patrons of those things the local place is known for.

Antagonistic gods sometimes exist. These don’t necessarily have to be evil—look at Loki—but they can be: Titans, frost giants, etc., feature in many myths. Nor is the god of death necessarily an antagonist. Still, the idea of a god or set of gods opposing the primary pantheon appears very often. Myths are stories, and stories need conflict. Someone with godly power can only be truly rivaled by another such being, and a dedicated foil is quite handy. Any of the gods can fill this role, as can any other being with power approaching godlike. (In many forms of Christianity, Satan has practically become an antagonistic god. This, combined with the elevation of saints, the hierarchy of angels, and so on, might even provide a glimpse of monotheism in the process of becoming polytheistic.)

Family matters

Once you have a sizable pool of deities, they can be related. Greece shows a nice portrait of the extreme end of this: the Olympian gods are one big, unhappy, inbred family, a very model for the European aristocracy of later centuries.

In a pantheon, gods can marry. (Whether they remain faithful, however, is another story. Or a lot of them, in the case of Zeus.) They can have children, and these will likely be gods in their own right. Some of the deities might be brothers and sisters. They may become lovers. They could even be all of these at once, since gods don’t necessarily have to play by mortal rules.

This fooling around can also extend to the inhabitants of the world. Every culture with polytheistic leanings has a story about a god (almost always a man) having relations with a mortal (nearly always a woman). Sometimes this is simply for love. Other times, it’s out of lust. In a few cases, it’s neither. The many lovers Zeus took are well-known; there are so many of them, we still haven’t run out of names for Jupiter’s moons. But everywhere you look in polytheism, gods and men are coming together.

And these unions, in mythology, often lead to children. A child with one divine parent might also become a god. Usually, there’s a tale as to why they are or aren’t fully divine. They could also be relegated to a separate rank of demigods, immortal beings with less power than the highest deities, but far more than any normal human. These might then go on to develop their own myths, like Heracles. (And don’t think this is limited to polytheism. A divine child is sort of the central figure of one of the world’s major monotheistic religions.)

The more gods a pantheon has, the more opportunity for relation. And the stories become endless. Not only that, but they can also echo the world itself. Children may follow in their parents’ footsteps, taking on similar roles, as with Aphrodite and Eros. Or they could become a blend of their two parents; the son of a sky god and a sea goddess might be the patron of the trade winds…or bringer of hurricanes. A forsaken child may become an antagonist. A city might choose to worship a demigod believed to be the offspring of a god and a local priestess or seer. The only limit is the imagination.

The story begins

Any way you slice it, polytheism has a reason for its popularity in fantasy. In real life, pantheons came about naturally, through centuries of cultural evolution. Fantasy creations didn’t. But they’re fun to think about, and they add a dimension to a world and its peoples. From a storytelling point of view, there’s not that much to be said of an omnipotent deity. But a hundred lesser beings, human in their flaws and faults, breathe a kind of life into a story’s religious backdrop.

That doesn’t mean you should go wild with the idea, though. Unless you’re writing a “mythic” story, where mortal and divine regularly intermingle, multiple gods should probably be just like one—out of the way. But they will leave their mark, everywhere from the calendar (Saturday) to place names (Athens) to any other facet of life. Any kind of religion shapes a culture. In the worlds you create, how they do it is up to you.

Sound changes: vowels

In this part of our little series, we’ll look at some of the sound changes that can affect vowels. Since there tend to be far fewer vowels than consonants in a language’s phonemic inventory, there aren’t as many places for these sound changes to go. For the same reason, however, the vowel system of a language is more prone to change, with new phonemes coming into use and old ones disappearing.

Vowels

Before we begin, think of (or look at) the IPA vowel chart. It’s usually depicted as something like a trapezoid, but it’s just as easy to imagine it as a triangle with vertices at /i/, /a/, and /u/. All the other vowel sounds—/e/, /y/, /ø/, and so on—are along the sides or in the middle. This conception will make a few of the sound changes described below seem more obvious.

Umlaut

The process of umlaut, as found in German, is an example of a larger phenomenon used referred to as fronting. Either term is fine for amateur conlangers, because everyone will know what you mean. Whatever you call it, it’s a change that causes vowels to move towards the front of the mouth.

Most commonly, fronting occurs under the influence of an /i/ sound. (In that, it’s almost like a kind of vowel harmony, or the vowel version of assimilation.) Sometimes, the /i/ later disappears, leaving behind the affected vowel as its only trace.

The Germanic languages embraced fronting to varying degrees, and they’re the best example around. German itself, of course, has the front rounded vowels ü and ö; the diacritic is often called an umlaut for just this reason. Old English, meanwhile, back /ɑ/ was fronted to /æ/. Swedish brought its /uː/ frontward to become /ʉː/. And the list goes on.

Fronting doesn’t always happen, so the back vowels aren’t totally lost. Instead, it can become a way to add in more front vowels; overall, languages tend to have more in the front than the back. Or it can cause mergers, as [y] becomes reinterpreted as /i/. This very thing happened in Greek, for instance.

Raising and lowering

Instead of bringing a vowel to the front, raising brings it up. Usually, this moves a sound one “step” up on the vowel chart: /a/ → /e/ → /i/. Intermediate steps like /ɛ/ can come into play, as well. An example of this process happening right now is in my own dialect of US Southern English, where some vowels are raised before nasal sounds. Thus, “pin” and “pen” sound alike.

The environment usually causes raising, but it’s not any specific sound that triggers it. Nasals can, as they do for me, but raised vowels later in the word can do it, too. So can other consonants. In general, it works out to yet another form of assimilation—vowels will tend to be raised by proximity to other “high” sounds. The reason it works so well for nasals is because they’re the highest in the mouth that you can get: in the nose.

Unlike fronting, raising seems to be more “effective”. But this makes it possible for other sound changes to come into play, sweeping into the vocalic void left behind. If raising gets rid of most instances of /a/, for example, some other sound will likely change to fill that gap.

The opposite of raising, lowering, is one such way of accomplishing this. It’s the same thing as raising, but in reverse: /u/ → /o/ → /a/ is a common trend. Front vowels appear to be harder to lower, likely from the massive influence of /i/, but it’s possible to do, say, /e/ → /ɛ/.

Nasalization

Vowels near nasal sounds might assimilate to them, in a change called nasalization. If the change is thorough enough, it can even result in the loss of the nasal consonant, leaving only a nasal vowel. That was the case in French and Portuguese, both of which have a set of nasalized vowels.

Any of the nasal sounds work for this, from /m/ to /ɴ/, but the “big three” of /n/, /m/, and /ŋ/ are the most common in languages, in that order. They’ll be the likely suspects. If nasalization occurs, then it will probably be on those vowels that precede these sounds; vowels following nasals are less susceptible to the change. Nasals at the end of a word or right before another consonant are the best candidates for the total nasalization that results in their disappearance.

A similar change can occur with /r/-like (rhotic) sounds, but this is much less common. It is a way to get a series of rhotic vowels like those in American English, and it’s conceivable that the difference between “regular” and “rhoticized” could become phonemic.

Lengthening and shortening

Solitary vowel phonemes can, in some cases, become long vowels or diphthongs. On the other hand, it’s easy for those to revert to short vowels. (And those can be shortened further, dropping out altogether, but we’ll get to that in a moment.)

These changes are very connected to the stress pattern of a word. Stressed vowels are more likely to be lengthened or broken into diphthongs. Unstressed vowels, by contrast, get the opposite treatment: reduction and shortening. That’s not the only reason these processes can happen, but it is the primary one.

The total elision of unstressed vowels is also quite possible. This can happen between consonants (syncope), at the beginning of a word (apheresis) or at its end (apocope). All of these are historically attested, both in natural language evolution and in borrowed words. Syncope, for example, occurs in British English pronunciations of words like secretary, while apocope turns American “going” to “goin'”.

Combining and breaking

Two vowels that end up beside each other (probably because of consonant changes) can create an unstable situation. Like the case of consonant clusters, vowel clusters “want” to simplify. They can go about this in a couple of different ways.

The easiest way is for the two to combine into a diphthong or long vowel. Where this isn’t possible, one of the vowels may assimilate to the other, much like consonants. Alternatively, the two might “average out”, fusing into a sort of compromise sound, like /au/ → /o/ (or /oː/, if that’s possible in the language).

Another potential outcome is a separation into two syllables by adding a glide. For example, one form of this diaresis is /ie/ → /i.je/. Once the vowel cluster is broken apart, other sound changes can then alter the new structure, potentially even re-merging the cluster.

Onward

Plenty of other vowel changes exist, but these are the most common and most defining. Next time, we’ll wrap up the series with a look at some of the sound changes that sit outside of the usual consonant/vowel dichotomy, as well as those that can affect a whole word. Also, we’ll conclude with a few rules of thumb to help you get the most out of your conlang’s evolution.

css.php