Let’s make a language – Part 11b: Adverbs (Conlangs)

Now that we have the theory out of the way, adverbs—whether words, phrases, or clauses—aren’t going to be too bad, for either Isian or Ardari. We already got a glimpse of them in both languages, back in the Babel Text, but now it’s time to see them for real.

Isian

As always, we start with Isian. As you may recall, Isian adjectives normally can’t appear without a head noun. Well, now they can, and that’s how we make most adverbs.

In Isian, we use postpositions, and the postposition hi is our go-to for adverbs. It’s the equivalent of English -ly, Spanish -mente, and so on, making adverbs out of adjectives. Examples might include ichi hi “beautifully” (from ichi) or bil hi “well” (from bil “good”, with no stem change like in English). Couldn’t be simpler.

We can fit these into sentences by placing them just about anywhere. Just before or just after the verb phrase are the most common, though. An example might be sha seri ichi hi “she sings beautifully”, which could also be written sha ichi hi seri.

Little hi can also work for phrases, with almost the same meaning. Take the sentence mi doyan hi cheren im “I see him as my brother”. Granted, it’s a little on the metaphorical side, but it illustrates the point. (You can write this one as cheren im mi doyan hi if you like, but that way emphasizes the object “him” rather than the adverbial phrase.)

For full clauses, we need a little bit more grammar. First, we have the general conjunction ha, which introduces adverbial clauses. In certain informal situations, we don’t have to put it in, but it’s mandatory otherwise. Second, since Isian uses postpositions, it also has “clause-final” conjunctions. Thus, the words that would translate as “before”, “after”, and so on appear at the end of the phrase, not the beginning, as in English.

These two rules cover most of what we need to know, and we can already make quite a few clauses. Here’s a couple of examples:

  • is hamas ha is inamas pane, “they ate before they went to sleep”
  • mit las an wasanda ha is likhas mida todo, “we couldn’t go because they wouldn’t let us”
  • em cosata ha cheren es abradi terta, “I came to see the mountains”

For all subordinate clauses like this, Isian’s default is independent. Dependent clauses are only allowed in a few cases, namely those of purpose or cause. (Desire or wanting, using the verb doche, allows dependents, too, but that’s not really an adverbial.)

To construct a dependent clause, all you need to do is use the infinitive form of the verb, which is the bare verbal stem (or 3rd-person singular present, which has the same form) preceded by cu. Thus, we might have cu chere “to see” or cu lenira “to read”. From there, the clause mostly follows English rules, except that the conjunction goes at the end, if it’s there at all.

Of our examples above, only the third can be rewritten as a dependent: em cosata cu chere es abradi. The first indicates time, which isn’t allowed to be “deranked” in this fashion, while the second has different subjects in the main and subordinate clauses. (Like English, we only get to use the infinitive version when the subjects would be the same.)

Ardari

Ardari, curiously enough, starts out easier than Isian: adjectives can be used as adverbs directly. They don’t inflect like this; they’re just…there. An example is ti ojet ajanga “she sings sweetly”.

Strictly speaking, Ardari doesn’t have simple adverb phrases, so we’ll skip ahead to the clauses. For this conlang, there’s a distinction in those. “Purpose” clauses (along with “wants” and perception, though these aren’t adverbial in nature) are always dependent, but everything else is normally independent.

These two groups are distinct in their position, as well. Dependents always precede the head verb, while independents are allowed to follow it, one of the few flaws in Ardari’s head-final nature. But independent clauses can be moved around freely, even fronted, like in English.

If that weren’t bad enough, adverbial clauses of time can appear in either form. In speech, it’s considered better to use the dependent form unless you absolutely need them at the beginning of the sentence. Writing prefers independents, mostly at the end of the sentence.

Okay, but how do we do it? For the independent clauses, there’s almost nothing to do. Put the adverbial clause after the main one, then put the appropriate conjunction at the end: my syne zejman anyerodyill salmotya byu, “I’ll give you these because I love you”. Since Ardari is otherwise head-final, the simple fact that something follows the verb is a sign that we have an adverbial clause.

Dependents are a little harder, but not much. As with Isian, we need an infinitive verb. For Ardari, it’s the verb stem followed by ky: dyem ky “to buy”, ivit ky “to see”. This goes at the end of the clause, followed by the normal conjunction: my fèse dyem ky chinod, “I went to buy food”.

Of course, there’s a slight problem of ambiguity that could crop up here. Because these clauses appear before the verb, with nothing to mark them off as special, we don’t really know when they start. In practice, though, it’s not that bad. Context helps. (Plus, it’s natural. No language is fully regular and unambiguous.)

Now, knowing all of this, we can get back to adverbial phrases. Ardari handles them like they were a special kind of dependent clause, using the infinitive form of the copula, èll ky: zall èll ky “like this”. (Perhaps in the future, this might evolve into an adverb-making suffix -èlky. Who knows?)

That’s it

Once again, it’s harder to describe something than to put it into action. That was the case with relative clauses a few weeks ago, and it’s the case today. But now we have adverbs, which fills in just about the last box in our list of parts of speech. Almost any kind of statement is possible now.

Next time, we’ll look at questions. Not the kind you certainly have, but the kind speakers of a language will be asking. We’ll see how they’re made and how we can make them.

Randomness and V8 (JS)

So I’ve seen this post linked in a few places recently, and I thought to myself, “This sounds interesting…and familiar.”

For those of you who don’t quite have the technical know-how to understand what it means, here’s a quick summary. Basically, the whole thing is a flaw in the V8 JavaScript engine’s random number generator. V8, if you don’t know, is what makes JavaScript possible for Chrome, Node, and plenty of others. (Firefox uses a different engine, and Microsoft’s browsers already have far bigger problems.) In JavaScript, the RNG is accessed through the function Math.random(). That function is far from perfect as it is. There’s no need to make it worse.

But V8, until one of the newest versions (4.9.40), actually did make it worse. An outline of their code is in the post above, but the main problems with it are easy to explain. First, Math.random() returns JavaScript numbers—i.e., 64-bit floating-point numbers—between 0 and 1. The way those numbers work leaves the algorithm 52 bits to play with, but V8’s code worked by converting a 32-bit integer into a floating-point number. That’s a pretty common operation, and there’s nothing really wrong on the face of it. Well, except for the part where you’re throwing away 20 out of your 52 random bits.

Because of the way V8’s RNG algorithm (MWC1616), this gets even better. MWC stands for “multiply with carry”, an apt description of what we’re dealing with. Internally, the code has two state variables, each a 32-bit unsigned integer, or uint32_t. These start off as seeded values (JavaScript programmers have no way of influencing this part, unfortunately), and each one undergoes a simple transformation: the low 16 bits are multiplied by one of two “magic” constants, then added to the high 16 bits. The function then creates its result in two parts, with the upper half of the result coming from one state variable’s lower half, while the lower 16 bits are taken from the other state’s upper half.

The whole thing, despite its shell-game shifting of bits, is not much more than a pair of linear congruential generators welded together. LCGs have a long history as random generators, because they’re easy to code, they’re fast, and they can give okay randomness for simple applications. But now that JavaScript is being used everywhere, the cracks are starting to appear.

Since V8’s Math.random() implementation uses 32-bit numbers and none of the “extra” state found in more involved RNGs, you’re never getting more than 2^32^ random numbers before they start repeating. And I do mean repeating, as linear congruential generators are periodic functions. Given the same state, they’ll produce the same result; generate enough random numbers, and you’ll repeat a state, which restarts the cycle. But that 2^32^ is a maximum, and you need some planning to get it. The magic numbers that make an LCG work have to be chosen carefully, or you can sabotage the whole thing. All the bit-shifting tricks are little more than a distraction.

So what can you do? Obviously, you, as a user of Chrome/Node/V8/whatever, can upgrade. The new algorithm they’re using is xorshift128+, which is highly regarded as a solid RNG for non-cryptographic work. (If you’re interested in how it works, but you don’t think you can read C++, check out the second link above, where I roll my own version in JavaScript.) Naturally, this doesn’t fix all the other problems with Math.random(), only the one that caused V8’s version of it to fail a bunch of the statistical tests used to quantify how “good” a specific RNG is. (The linked blog post has a great visualization to illustrate these.) Seeded, repeatable randomness, for example, you’ll still have to handle yourself. But what we’ve got is good enough for a lot of purposes, and it’s now a better foundation to build upon.

Magic and tech: introduction

Now that the New Year’s pleasantries are out of the way, it’s time to get back to the work of worldbuilding. It’s work that never truly stops, you know. Worldbuilding isn’t just a rabbit hole, it’s a bottomless pit for your spare time. But it’s undeniably fun, in that creative sort of way. In that sense, these are my favorite posts to write.

Anyway, this post is going to serve as an introduction to a new series of worldbuilding articles. These will be about the “regular” length for my posts (about 2,000 words), and they’ll cover a very specific subject: the interaction of magic and technology. Look around the fantasy section of your favorite bookstore, whether physical or virtual, and you can find plenty of examples of worlds where these two forces coexist. It’s a staple of certain subgenres, after all.

But many of these worlds are just our own, only viewed from a different angle. So much fantasy (I’m not only talking about books here, but games and movies and TV, too) takes the classic D&D approach of “medieval, but with wizards“, and that’s really a shame. Why? It’s simple, if you think about it. Magic changes the game. With magic, the rules of history don’t apply.

Now, I’m not saying all fantasy is this way. There are plenty of stories out there that take a…nontraditional approach to magic and technology. The “magitech” and “technomancer” styles are good examples of this, but not the only ones. Any segment of fantasy has its highs and lows; to me, great worldbuilding is definitely one of the highs. That’s not to say I don’t enjoy a good sword-and-sorcery romp as much as the next guy, but I do find more fulfillment out of a detailed setting that feels real. It’s hard to describe, but depth and logic play strong parts.

And I especially love good magic systems. More importantly, I want to see a world that understands its magic, a world that reacts to it. I can suspend my disbelief for things that are physically impossible, but not those that are logically impossible. Throwing fireballs, summoning demons, reviving the dead—and, for sci-fi, add in FTL travel, teleportation, and so on—those are all fine, as long as there’s a reason for them. It can even be a literal miracle, if that fits the setting. Just don’t make it a deus ex machina, that’s all.

The intersection

So let’s get back to this whole “series” idea. Remember that? Here’s what I’ve got in mind.

First, this is an irregular series. It won’t be every week, and it doesn’t have a definite end. I could write about something like this for an eternity, but I won’t. Instead, “Magic and tech” posts will be interspersed with the more regular worldbuilding and literary articles on Mondays. I’ll try to do one a month, but don’t hold me to that.

Second, I know I’ve spent the last few months talking in generalities. This will be different. I’m going to take a specific example and work it to the ragged edge. The setting I’m making will have a few built-in assumptions, and I’ll go over the basics in a moment. Almost everything else I intend to flow logically from those assumptions. My logic doesn’t always work the same way as everybody else’s, so feel free to call me out when (not if) I screw up.

Third, the setting will be mine, but don’t let that stop you from swiping bits and pieces of it for your own. Maybe the assumptions are altered slightly, or history took a different path. Who cares? Change the names and a few of the details, and it’s yours.

The assumptions

There are, to a first approximation, an infinite number of possibilities for combining magic systems, technology development, cultural development, and historical circumstance. That won’t do. We need to narrow things down, so I’ll be starting from a known origin point. The core assumptions I’ll be making are:

  1. Magic exists. That’s a no-brainer, if you read the title of this series, but it bears repeating. Specifically, magical aptitude is a function of a few different factors, not all of them scientific. All we really need to know, though, is that about one out of every 80 people has the talent, and about two out of three of those never realize they have it or give up trying to harness it. Actual mages make up about 1/250 of the adult population.

  2. Magic is known. People understand that some among them have a power unexplainable by natural laws. To them, it’s taken as a given, the same way some people can write songs or make statues from marble. It’s a gift, yes, but no more than any other creative gift.

  3. Magic is fairly predictable. Sure, there are a lot of possibilities for thinking outside the box, but most mages in this setting are conservative and low-key. They’ve made something like a cross between art and science, and most of them don’t mind keeping it that way.

  4. Technology is at a level roughly comparable to the High Middle Ages. No steam engines or (technology-based) electricity, but a few peripheral countries are lacking in mages, and they have developed the earliest gunpowder weapons as a defense.

  5. Technology stagnated earlier in history, due to the conservative nature of most mages. Within living memory, however, things have started to progress again. We’re not talking a millennia-long Dark Ages—A Song of Ice and Fire, I’m looking at you—but about 400 years of the status quo.

  6. Religion is…complicated. The supernatural is generally agreed to exist, but there is no single faith that unites a vast section of the world. Most religions do favor magic over technology, but some are the opposite, considering magic anathema. A couple eschew both, feeling that magic is too powerful for mortals, but technology is too soulless.

  7. The inhabitants of the world are otherwise modern humans. This is almost an afterthought, but it helps to be clear on this point. We’re working with people like us, not aliens or elves.

More to come

So that’s the rough sketch. Now it’s time to fill in the blanks. As I write this series, I’ll fill in a table of contents down here. (The hardest part will be remembering to do it!) As always, comments and constructive criticism are most welcome, and I’d love to hear about your own creations. Other than that, there’s nothing left to say but this: strap yourself in and enjoy the ride.

Contents

  1. Travel
  2. Information technology
  3. Information
  4. Power
  5. Weapons
  6. Defenses
  7. Medicine
  8. Heating and cooling
  9. Construction
  10. Art

Let’s make a language – Part 11a: Adverbs (Intro)

As we move into Act II of our language-making show, let’s pick up one of the loose threads from last week’s Babel Text: adverbs. When I say “adverb”, though, I’m not just talking about words like English “hardly” and “badly”, but any word or phrase that changes and refines the meaning of a verb. That includes certain phrases that we can call adverbial or subordinate clauses. We’ll see what those are in just a minute, but we should first back up and think about the very idea of an adverb.

The forgotten one

Adverbs, broadly speaking, are to verbs what adjectives are to nouns. They modify the meaning, allowing us to express finer distinctions. Verbs, remember, represent actions, so adverbs are what we use to tell how an action happens. Examples like “she sings happily” or “the clouds are hanging menacingly” show the most familiar of these adverbs.

Of course, there’s always more to the story. Not all adverbs really modify verbs. Some in English, for instance, modify whole sentences. Grammar pedants don’t like it, but that’s what has happened with words such as “hopefully”. And English also has words like “manly” that look like adverbs but fill the role of an adjective.

And then there are languages that don’t actually have a separate collection of adverbs at all. Many of these have no problem allowing an adjective to modify either a noun or a verb; in the latter case, it functions like an adverb, even though there’s no indication that it is one.

(If that weren’t enough, there is another way of defining adverbs: as grammatical words that don’t fit into any other category. That’s a negative definition that isn’t exactly helpful to those making their own languages, but it’s useful to know. Some languages do see adverbs this way, as a closed class of words separate from the other parts of speech, with the more common “adverbs” being derived regularly from adjectives.)

Really making

The largest group of adverbs (or what would be called adverbs) in most languages includes those derived from adjectives and meaning something like “in an X way” or simply “like X”. In English, we can make most of these with the -ly suffix: “real” becomes “really”, etc. Plenty of other languages have their own counterparts that are very similar in use, including Spanish -mente and Japanese -ku, to name only two.

Another common option is, well, nothing at all. Adjectives in many languages can be used directly as adverbs. In these cases, they might not be inflected as usual for case or number (since they won’t be modifying a noun), and they likely won’t appear in their customary position. But those would be the only ways you could tell the difference.

Every other word derivation is possible, too. You can have suffixes, prefixes, extra words before or after, and just about anything else you can think of. For widely-used adverbs, irregularities might arise, especially if the adjective itself already has them. English good is one example, forming the adverb well, to the consternation of schoolchildren everywhere. (The regular goodly also exists, but it has a much different connotation.)

Finally, adverbs aren’t necessarily always derived from adjectives. Words like “soon”, for example, are only adverbial. (It’s not a coincidence that most of the ones you can think of have something to do with time.) It’s perfectly possible to make an adverb from a noun or even a verb, as well. But these probably aren’t going to be made into a simple word; we need a phrase.

As an adverb

When one word just won’t do, adverbial phrases come to the rescue. What are they? Well, it’s right there in the name. An adverbial phrase is nothing more than a phrase that acts like an adverb. (Coincidentally enough, that last sentence perfectly illustrates my point: “like an adverb” is, in fact, an adverbial phrase!)

In English, many adverbial phrases are essentially prepositional phrases used as adverbs. They’re more likely to use “temporal” prepositions like before or when, since those don’t make as much sense for nouns, but anything is possible.

Grammatically speaking, the same is true. If a language allows them, adverbial phrases tend to take the same form as prepositional (or postpositional or whatever) phrases. It’s easy to see why, as the adverbial function only generalizes the idea of prepositions.

Because the clause

The adverbial clause, on the other hand, is a totally different animal. Here, we’re not talking about a little noun phrase, but a whole clause. It could be an entire sentence (an independent clause) or only a fragment unable to stand alone (a subordinate clause). Either way, it also works as an adverb, so it’s a good idea to look at it here.

The key difference between adverbial phrases and clauses is that a clause has a predicate. It’s usually a verb, but some languages only require something with a verbal meaning. (A language with a zero-copula construction, for example, could conceivably have a subordinate clause with only a subject and an object.)

Some of these verbs will be inflected like any other verb in the language. Take, for instance, this English sentence: “It started raining while I was walking home.” The marked part is the adverbial clause, and you can see that, except for the conjunction while, the clause could stand on its own as a sentence.

Now, on the other hand, let’s instead say, “I saw the rain while walking home.” This time, we still have a predicate (walking home), but it can’t stand alone. The special form of the verb, walking instead of walk, is our cue for this.

In English grammar, we call the first example an independent clause, while the second is a dependent one. Some linguists instead refer to them as balanced and deranked clauses, respectively. Either way, the difference between them is clear: one can be “broken out” into its own sentence, while the other can’t.

Counting the ways

Adverbial clauses come in a few different categories. Each has a different meaning and a different set of conjunctions that connect it to the rest of the sentence.

Here are the primary types of clauses, each with a brief definition and an example sentence. We’ll use them later. In the examples, the conjunction that introduces the adverbial clause is emphasized, and the clause itself is everything that follows.

  • Purpose: the purpose of an action; “I went home so that I could take a shower”

  • Time: when something happens, relative to some other time or event; “the boys played in the sand when they went to the beach”

  • Reason: the reason why something happens; “I can’t come because I am sick”

  • Place: the position or location of an action or event; “they like it where they live”

  • Manner: the way something is done; “this book wasn’t written how I would have liked it”

  • Condition: a possibility or consequence, an “if-then” situation; “bad things will happen if you go out in the storm”

There are a couple of others, but they work about the same. Clauses indicating results are similar to those of reason, and concessions are pretty close to conditions. Comparisons are worthy of their own topic, which will come a bit later.

Any of these clauses, though, can be used as adverbs. In English, as you can see above, they often follow the verb, like an object; this isn’t absolutely necessary, and any one of them can be rearranged to put the adverbial clause at the front.

Note, too, that they’re all independent. Taking that away isn’t quite as easy, and it doesn’t always work. It does in some cases, though, as long as the subject of both clauses is the same. We could say, for example, “I went home to take a shower“, creating a dependent clause. Mostly, English prefers “balanced” clauses, to use WALS terminology, permitting “deranked” as an occasional option. (In terms of style, dependent clauses sound slightly more formal or less “personal”, at least to me.)

Constructing the clause

While the general definition of an adverbial clause isn’t that dependent on a specific language, how they’re formed is. For English, as you can see, you first need a conjunction. Then, you have the clause itself. For dependent (or deranked, if you prefer) clauses, the verb appears as either an infinitive or a gerund, depending on what you’re trying to say; either way, it’s not the usual inflected form that you’d use in a “proper” sentence. Independent (balanced, hence the name) clauses have fully inflected verbs, although that isn’t saying much in English.

But how do you do it in a conlang? Well, that truly depends. They’re probably going to look a lot like prepositional phrases, however you do those. Verb-final languages will likely end an adverbial clause with the conjunction, and the clauses themselves will tend to be farther forward in the sentence. SVO or VSO languages would go the other way, more like English.

But this kind of phrase isn’t a core part of a sentence, so there’s nothing to stop it from “floating”. Adverbial clauses can show up anywhere. English allows them at the front, in the back, and even in the middle. Of course, you can be strict, too, if you like. You aren’t going to see many adverbs at the end of a Japanese sentence, after all.

Next up

Next week, we’ll look at how Isian and Ardari tame these monstrous clauses. Then, it’s time to answer something you’ve probably asked once or twice: how do we ask a question?

Looking forward to 2016

So, it’s a new year. The slate has been cleaned. We can put 2015 behind us, and look ahead to 2016. From a programming point of view, what does this new year hold? Let’s take a look.

Programming languages

This year should be an exciting one if you like programming languages for their own sake.

  • JavaScript: Most everybody is using a browser capable of most of ECMAScript 5 (ES5). By the end of the year, expect both parts of that to increase. More people are going to have modern capabilities, and the browsers themselves will cover more of the standard. Speaking of standards, I’d look to ES6 support becoming more widespread in browsers, even Microsoft’s.

  • C++: The next revision of the C++ standard, C++17, is still a ways away. (You’re crazy if you’re betting on it actually coming out in 2017. Remember, C++11 was codenamed C++0x for years.) However, we should start seeing parts of it becoming fixed. Ranges are a big thing right now, concepts are coming (finally!), and it looks like C++ might get some sort of compile-time reflection. Things are looking up, but we’re not there yet.

  • Perl: I’m serious. Perl 6 is out. (I think that leaves Star Citizen as the final harbinger of Armageddon.) In the works for a decade and a half, with a set of operators best described by a periodic table, and seemingly designed to be impossible to implement, who can’t love Perl? At the very least, it’ll be fun to write in, and the new, incompatible version will spur a new generation of Perl golfers and other code artists. But I think it might turn out a bit like Python 3. Perl 5 has history, and that’s not going away.

  • The rest: I can easily see Rust gaining a bigger cult following over the next year, especially at places like Github. PHP has their version 7, but the less said about PHP, the better. C# and Java are going to be simmering for another twelve months, at least, and I don’t see much new news coming out of either of them. Ruby will continue its slow slide into irrelevance, probably dragging Python with it. (I wouldn’t mind them taking Haskell along, but I digress.) Newcomers will arise, and I’d say we’re in for another round of “visual coding”. And hey, maybe this will finally be the year for Scala.

Hardware and the like

The big thing on everyone’s lips right now is Vulkan, the official successor to OpenGL. It was supposed to be out in time for Christmas, but it got pushed back. (Funnily enough, the same thing happened two years ago with Kaveri, AMD’s first processor line that could support Vulkan. But I’m not bitter.) Personally, I don’t see much out of Vulkan this year. It’ll be released, and we’ll see a few early, buggy drivers and experimental alphas of games, most of which will be glorified tech demos. I’d give it till 2018 before I start worrying about replacing OpenGL.

Tiny computers are going to get bigger this year, I think. I mean that in a figurative way, of course. The Raspberry Pi 2 is the big name in this field, but you’ve also got the BeagleBone and things like that, not to mention the good old Arduino. However you look at it, it’s a mature area. We’ve moved beyond revolution, now it’s time for evolution. These computers will get more powerful, easier to use, and more ubiquitous. Next Christmas, I can easily see a stick computer being like this year’s quadcopters.

On the other hand, as much as I hate to say it, I’m not holding out a lot of hope for 3-D printing. We’ve been hearing about it for half a decade, and there has definitely been incremental progress. But 2016, in my opinion, is not going to be the year we see inexpensive 3-D printers flying off the shelves. They’ll stay in the background. (The whole “Internet of Things”, however, will only grow, but it’s not intended to be programmable, so it doesn’t help us.)

Libraries, engines, etc.

Look for Unity and Unreal to continue their competition, with a bunch of smaller guys chomping at the bit. Godot, assuming they don’t screw themselves over by switching to Vulkan prematurely, might get a boost as the indie engine of choice. And JavaScript engines have near-infinite upside, especially for mobile coding. Game development in 2016 will be like it was in 2015, but better in every way.

I do think the Node.js fad is dying down, and not a moment too soon. That doesn’t mean Node is done, only that I see people evaluating it for what it is, rather than what it’s advertised as. It’s the same thing as Ruby a few years ago, back in the early days of Rails. Or JavaScript and Angular a couple of years ago, for that matter. Still, Node is a solid platform for a lot of things. It’s not going away, but this is the year that it fades from the spotlight.

The same can be said for the current crop of JS web frameworks. There’s no chance of the whole Internet getting behind a single framework, nor two or even ten. But this is an area where the churn is so great, what’s popular next December hasn’t even been written yet. I can tell you that it’ll be slower, more bloated, and less comprehensible than what’s out there, though.

In the end

For programming, 2016 has a lot to look forward to, and I’ve barely scratched the surface here. (I haven’t even mentioned learning to code, which will get even bigger this coming year.) Whether native or browser, desktop or mobile, it’s a good time to code.

More on calendars

When this post goes up, it will be the start of 2016. A new year. Time to throw out those old calendars and set up the new ones. (Well, probably not. Most people just use the calendars on their computers or phones these days.) But before you toss that record of the old year, take a look at it, because it’s actually quite interesting.

A couple of weeks ago, I talked about holidays. This time around, I’m going to look at the whole calendar. Not just our own, mind you, but others throughout history and the modern world. Some of them have features that might be useful to a writer looking to make his fantasy world distinctive.

Into the west

Let’s start with our familiar western calendar. It’s the simplest, but only because we’re familiar with it; if we grew up using, say, the Islamic calendar, then we would be used to that. Now, you already know the basics, if you’re above the age of 4. The year is divided into twelve months, beginning in January and ending in December. Months have fixed numbers of days, but they aren’t the same: we’ve got four of them with 30 days, seven with 31, and then February, which can have 29 in leap years (like this one), but normally has 28.

Months can then be divided into weeks of 7 days each (though only February divides exactly). Days, of course, are 24 hours long, not counting Daylight Saving Time, and hours are subdivided into 60 minutes, which are, in turn, subdivided into 60 seconds. Going back to the other end, years are counted from the putative birth of Christ, with the only real nod to religious diversity being the “modern” names for either side of the dividing line: Christian Era (CE) and Before Christian Era (BCE) versus the traditional Anno Domini (AD) and Before Christ (BC). We can also group the years into decades, centuries, and millennia, but these are more a notational convenience than a function of the calendar.

So that’s what the Western calendar is. But why is it like that? Why are the months uneven? Why does the year start in January? Do we really need leap years?

Let’s start with the first question there. Our calendar is the result of a long chain of cause and effect reaching far back into history, but its current form was largely determined by the Romans. They were the ones that gave us our twelve months, with essentially today’s names. As usual, though, it’s not that simple.

First off, the Roman (Julian, technically; Julius Caesar’s reign saw more than its share of calendar reforms) New Year was in March, so January and February were at the end of the calendar. February 29, the leap day, would have been the last day on the list. The year starting in March basically lasted until the Gregorian reform: sometime since 1582, depending on where you live. (In America, the one time a non-specialist would encounter the Julian-to-Gregorian switchover is in genealogy. Some dates in the 18th century—when Britain and the colonies that would become the US switched—are recorded as OS or NS. These stand for Old Style and New Style, meaning what we now call the Julian and Gregorian calendars, respectively.)

Incidentally, moving the year’s starting date messed up the naming. September comes from the Latin word for “seven”, which you wouldn’t expect from the ninth month. But a few hundred years ago, it would have been linguistically accurate. The same goes for October (eight), November (nine), and December (ten).

Just about the one thing the Romans didn’t give us for our calendar is the AD/BC split. That one came a few centuries later. Before then, years were reckoned from the time of a well-known event or the coronation of a noble figure such as a king or emperor.

Written in the stars

Let’s turn to the scientific aspect of the calendar for now, since that’s where we can get more insight. We’ll get back to the history shortly, I promise.

The year, scientifically speaking, is the time it takes the Earth to orbit the Sun once, while the day is how long it takes our planet to rotate on its axis. These are the only “natural” units of time measurement; weeks and months and hours are all human invention. Both the year and the day can be found by observation: the day is roughly the time between one noon and the next, and the stars (including the Sun) will return to the same position in the night sky after a year. (Technically, this isn’t entirely accurate, but the inaccuracies are far below the calendar’s resolution.)

Clever readers will note that we’ve already run into a big problem: the year is not made of a whole number of days. It’s not 365 days long, nor is it 366. In fact, it’s something like 365.2422 days. So, if our calendar only had 365, we would effectively lose a day about every four years. But if we made every fourth year a day longer, that makes up for the discrepancy. Hence, leap years.

The Julian calendar had one every four years, no matter what. By the time of the Gregorian reform, the difference between 365.2422 and 365.25 had added up, and they had to skip a few days to get things back on track. (How many days depends on when the reform took place.) To stop that from happening again, they also changed the rules to make only certain century years leap years. And that’s why 2000 was special: the next leap year ending in 00 won’t be until 2400.

The sun and the moon

There’s another way to count the days, and it can even work at night. The Western calendar is a solar calendar; it’s based around the sun. But our months are remnants of a connection to a lunar calendar. It’s right there in the name, too.

Other calendars are exclusively lunar in nature. The Islamic calendar is one example. Months start and end based on the phase of the moon, and in many Muslim countries that is a literal statement, even today. But the lunar period isn’t a whole number of days, either, so Islamic months can have either 29 or 30 days. Due to religious circumstances, the Islamic calendar has exactly twelve months, meaning that it will always be short of the solar year. The current year for Muslims is 1437, and the calendar’s epoch (basically, its starting date) was in 622. Simple arithmetic shows that 1394 solar years have passed since then, a difference of 43.

This doesn’t fit with the seasons, but it’s not really meant to. An alternative is to try to combine the lunar and solar cycles into a single calendar. In the West, we have only the remnants of that, in our months, but some other cultures use what’s called a lunisolar calendar. The most familiar example would be the Jewish religious calendar. Here, we still have twelve months, and they’re still based on the cycle of the moon. Normally. But this is a solar calendar, too, and the seasons are important. So, to keep them roughly where they should be, the Jewish calendar adds extra months. It’s like our leap days, but 30 at a time. Seven of these every 19 years keeps things fairly even, plus or minus a month.

From scratch

I’m not going to try to explain the Mayan calendar. It confuses me, so I don’t even know where to begin. Instead, I’ll move on to some thoughts on making a fantasy (or even sci-fi) calendar.

First things first, you need to know the relationship between the year and the day. That’s the key. If you’re working with Earth (or a reasonable facsimile), you already know this, and you can move on. Otherwise, you’re deep in worldbuilding territory, and you’ll probably have to work things out yourself. In that case, remember that it’s going to be pretty rare to have a year with an integral number of days. In fact, it’s almost impossible, and it’s surely temporary. Just about every calendar, with the possible exception of one for an interstellar empire, will have leap days of some sort. They might be scattered throughout the years, or they may come in bunches, but they will be there.

The year and the day mark the cornerstones of the calendar, no matter what kind you have. In between, however, things are wide open. Obviously, lunar-based calendars require at least one moon, and that moon needs to be in an orbit that fits. Phobos, the inner moon of Mars, would be completely useless for a lunar calendar, for example: its orbital period is about 7-1/2 hours. Multiple moons give us the possibility of measuring by conjunctions, but that can get into some heavy math that might be too much for a fantasy world. That’s not to say it’s not worth trying, just that it may not be worth the effort in the end.

Even without a big moon in a nice, useful orbit, cultures would likely develop divisions of time between the day and year. Seasons are appropriate for this, and I’ve got just such a post for that. Weeks are more of an invention of civilization. Our seven-day week dates back to Babylonian times, but many cultures have a shorter period of days than the month. Cyclical religious observances are one excuse for a week, but more mundane concerns, like markets, can also come into play. (A story I’m currently writing has a culture with a week of six days, while the French Revolution tried to institute a ten-day week. About the only place they succeeded was in D&D’s Forgotten Realms setting.)

Now, when the year starts is a question that depends heavily on not just your world but your culture. The Romans liked it in spring, and that has a lot going for it in an agrarian society. The Gregorians moved it to January (to have it closer to Christmas or something like that), but that put it in wintertime. There are arguments for just about any day of the year to be New Year’s, but it’s probably—though not always—going to be at the start of the month, and the date will likely have some cultural, religious, or economic significance.

We can go “below” the day, too, but we begin to run into limitations of technology. Hours are fairly easy, and many early cultures settled on numbers like 12, 24, or 60 of them in a day. Why? For the same reason that there are twelve inches in a foot and twelve (troy) ounces in a pound: it’s easier to divide into halves, fourths, and thirds. (Decimal numbers are great for working on paper, but horrible for eyeballing.) Of course, another planet with a different rotation period will have different hours. On Mars, the obvious “hour” would be about a minute and a half longer than ours.

Measuring minutes and seconds is…harder. It’s likely beyond the reach of many early civilizations, and they likely wouldn’t see the need for it, anyway. We have 60 minutes in an hour or seconds in a minute because, again, 60 is easier to work with until pen and paper are widespread calculating devices. If hours had only been subdivided after the French invented the metric system, we’d probably have 100 of them. (Put the metric system in ancient times, and we would all be using Swatch’s silly Internet Time today, I guess. Anybody remember that thing?)

Last but not least, we come to the reckoning of years. For the West, we count from a monk’s imperfect calculation of the birth of Christ. Muslims go by the rather more specific date of Muhammad’s move to Medina, while Jews start their calendar with the traditional date of the Biblical creation of the world. Other options exist, though. One common one in history is dating by years since a ruler’s rise to the throne; when a new ruler is crowned, a new era begins. Another is a cycle of years called indictions. In this system, the last year of one cycle is followed by the first of a new cycle. We might say that this is the seventh year of the 2010s, for example, or the sixth year of this decade. In a way, the Mesoamerican calendars function something like this. (I’ve actually seen this in fantasy before, too. Scott Lynch, in The Lies of Locke Lamora, has a kind of indiction system. Each year is named after one of the setting’s twelve gods, in a specific order. When the last one is reached, the whole thing loops back to the start.)

Happy New Year

However the calendar works, it gives an otherworldly feel to any fiction. To give you one example, my aforementioned story is set on a different planet. (Well, the first part is mostly set on Earth, but that’s neither here nor there.) That planet has a different day length (24 hours, 23 minutes, approximately) and year length (about 374.16 local days) than our own, meaning that I had to do some work.

What I came up with was a calendar of twelve months, each 30 days long, which doesn’t really have any relation to the orbital period of the planet’s moon; it’s more a matter of convenience. Each month is made of five weeks of six days. The extra days are scattered around the calendar, a few at the end of each season. There are more of them at the end of spring, and fewer at the end of fall, and this has a scientific basis: the eccentricity of the planet’s orbit. Days in this fictional world are 24 hours long, but their hours are slightly longer than our own. Hours can be divided into minutes, and further into seconds, but this is more a math trick than something practical.

You can do things differently, and you probably should. What you make should be tailored for your fictional world, for your story. The key is suspension of disbelief. It doesn’t really make much sense for a world with no connection to Earth at all to be calling their months October and their days Saturday. (I didn’t talk much about the names of the days. They’re pretty obvious, though: planets or gods, not that there’s much difference in older times.) Now, you can say that it’s an author translation of unfamiliar terms, and that’s fine, but taking a little bit of time to work things out can pay off in making your world feel more real.

Let’s make a language – 2016 Special

We’re taking a bit of a week off this time. Don’t worry, there’s more to come later on, but today is the first day of the new year, a time to take a break, a time to reflect on the 366 days to come. (2016 is a leap year, remember.) We’ve gone through ten parts of this series already, and we’ve come a long way. But there’s still a longer way to go, although the pace for this year won’t be quite as hectic.

So, to celebrate this new year of conlanging, here’s what we’re going to do. Today, you’ll get to see the first significant text in each of our two languages, Isian and Ardari. That text is the Babel Text, the first nine verses of Genesis 11. Sure, it’s a religious writing, but that’s okay, because we’re not interested in it for its theology, but for its linguistics.

Babel

The Babel Text is one of those “classic” tests of a conlang. It really has it all, grammatically speaking: tenses, moods, aspects, and all those different kinds of clauses. (Some of them we haven’t seen yet, but we can deal.) Plus, the story itself is about language, the Biblical account of the making of the world’s languages. Essentially, it’s a fable, one originally meant to be told orally. We’ll write it here, though, since that’s easier.

If you want to play along at home, you can use whichever version of the text you like. I’ve gone with this one, derived from the NRSV:

  1. Now the whole earth had one language and the same words.

  2. And as they migrated from the east, they came upon a plain in the land of Shinar and settled there.

  3. And they said to one another, “Come, let us make bricks, and burn them thoroughly.” And they had brick for stone, and bitumen for mortar.

  4. Then they said, “Come, let us build ourselves a city, and a tower with its top in the heavens, and let us make a name for ourselves; otherwise we shall be scattered abroad upon the face of the whole earth.”

  5. The LORD came down to see the city and the tower, which mortals had built.

  6. And the LORD said, “Look, they are one people, and they have all one language; and this is only the beginning of what they will do; nothing that they propose to do will now be impossible for them.

  7. Come, let us go down, and confuse their language there, so that they will not understand one another’s speech.”

  8. So the LORD scattered them abroad from there over the face of all the earth, and they left off building the city.

  9. Therefore it was called Babel, because there the LORD confused the language of all the earth; and from there the LORD scattered them abroad over the face of all the earth.

So that’s what we’re working with. (Yours, of course, may be different.) Now let’s see how it looks in our made-up languages.

Isian

First off, here’s the full text translated into Isian:

  1. Nec hi, e sota sata fanas yan sangoy wa es ilir beti.

  2. Ad ha is mishas si way keres, is cosas ta abe e Shinar tor i, ar is dalegas.

  3. Ad is kis lan es, “Cosa, ad tinte gados, ar becre sota hi sim.” Ar is fanas gadocat sencat afich, wa arcay empan afich.

  4. Toc hi, is kis, “Cosa, ad oste lan ir ta eblon, wa ta farin ke ey poy e timirot i, ar tinte ni lan ir. Loydaro mit hade par nos basagima e fayan e sata o sos.”

  5. E Domo esto cosas ha i chere e eblon wa e farin ke ostec im nakhit at terta.

  6. Ad e Domo kis, “Chere, is e yan cudisa, ar sota sim o fana yan sangoy, ar ne yahi e cu nawe ed ke te im is o. Anocal ke is wachi cu te nec nos e arisosan im ir.

  7. Cosa, esto wasa, ar golbata si sangoy til ni, ha is an nos noyta le gonas terta.”

  8. Teti, e Domo hade basagis sim til fo e fayan e sata o sos, ar is tarcas cu oste e eblon.

  9. Teyno, i par pasa Babel, ha e Domo golbatas til e sangoy e sota sata o todo; ar e Domo basagis til fo e fayan e sata o sos.

Grammar

Most of the grammar is what we’ve already seen. Some of it, though, is new, particularly the adverbs. We’ll get into the details in later parts but here’s a preview that tells you all you need to know to get through the text:

  • Isian adjectives (and some nouns) can be changed into adverbs by putting hi after them. This works much like the English suffix -ly: ichi “beautiful” becomes ichi hi “beautifully”.

  • Adverbs usually go before their verbs, but they can also be moved to the front of a sentence.

  • A whole prepositional phrase can be used like an adverb by putting ha before it.

  • Conjunctions are close to their English counterparts. They’re simple little words that link sentences; in the Babel Text, for example, we have ad and ar, both roughly meaning “and”, but with slightly different connotations. Again, we’ll give them a closer look later on.

We get our first tastes of word derivation here, too:

  • The suffix -cat, when attached to a noun, changes the meaning to that of a material: gado “a brick”; gadocat “brick”.

  • One way to make an adjective into its antonym is by the prefix/suffix pair a-an. We see this in arisosan “impossible”, which is actually derived from risos “possible”.

  • Finally, the suffix -nas can convert a verb into a kind of “abstract” noun: go “to speak”; gonas “speech”.

We’ll see a lot more of derivation in later parts of the series.

Vocabulary
Isian English
abe a plain
ad and then…
ar and (conjunction)
arcay tar (or bitumen)
arisosan impossible
basagi to scatter
bet word
cudisa people, group
domo lord
empan mortar
esto down, downward
farin tower
gado(s) a brick
gadocat brick (material)
golbata to confound
gonas speech
hade away
ilir same
keres while
loydaro otherwise
misha to move
nakhit mortal
nec now
noyta to understand
pasa to call by a name
sangoy language
sencat stone (material)
si east
tarca to stop doing
teti so, because of this
terta so as to…
teyno therefore
til there
timiro heaven
toc then
tor a land
wa and (noun phrase)
wachi to desire, wish
yahi only
yan one

Ardari

Now, let’s switch to Ardari. Again, here’s the full text:

  1. Lokhi omaritö jane kolrachevi sun lagrelltös nyas perodjyn.

  2. Ysar sälltö tov tapsined ky vi, Chinare me dablan wi mokiti lim tonedjyn, ysar jeren wizèledjyn.

  3. Lataj ry isedjyn, “Tonje, tyolton grätje, ajon warhan sechaje.” Gwanan bòte tyoltanvi, pyuryse bòte pamöre peredjyn.

  4. Drä isedjyn, “Tonje, präzdanvi, qa me khaj èlyasòndös wi kombran lataj da mollje. All grätje, sinran omarini sòletö ori oprös utuweryll.”

  5. Tsoratö qa sèlokynar molledadyt präzdantövi kombrantö ivit ky tèghdaradjyn.

  6. Tsoratö isad, “Ivitje. Ysar jane banöladan èllejyn, ysar me laz jane kolrache perejyn, zalman qa aghell me sòto ky èlla. Duqom qa agh ky märyke ysar da urburdosdill.

  7. Tonje, tèghdarje, ysoj kolrache jeren kamrulje, lataj me simënda rejvetell kyus.”

  8. Èlladjyn Tsoratö ysar jeren tov omarini sòletö ori utuweradid kyus, ysar präzdantö moll ky uq.

  9. Yse Babèle filtyda, Tsoratö omarini kolrache jeren kamruladjyn, jeren tov Tsoratö ysar omarini sòletö ori utuwerad byu.

Grammar

Ardari looks much different, doesn’t it? Much more complicated, too. As with Isian, we haven’t really gone over all the grammar bits you need, so here’s a primer:

  • Ardari lets you use most adjectives directly as adverbs, with no changes needed.

  • Nouns, noun phrases, and some adjectives instead require you to follow them with èll ky. (This is the infinitive form of èll- “to be”.) An example would be kone èll ky “like a man, manly”.

  • “Subordinate” clauses are complicated enough that the full story will have to wait. Some of them let you use a bare verb stem followed by ky, like above, and you use them as a postpositional phrase before a sentence’s head verb. Others appear mostly as normal, but they follow the verb. (This is the only way Ardari lets you put something after the main verb of a sentence.)

Ardari’s words also tend to have more subtle shades of meaning, and these don’t always line up with their English translations:

  • nyas means “now”, but only as an adverb
  • drä, meaning “then”, connotes a time long in the past
  • jeren “there” is used for things very far away; closer things instead use pren
  • oprös normally works as an adjective meaning “other”; as an adverb, its meaning becomes “otherwise”
  • kyus denotes an effect or implication
  • èllad literally means “it was”, but it’s also used to introduce a subordinate clause
  • filt- “to know as” is a ditransitive verb, like “to give”

We’ll see conjunctions later on, but we have two here. They’re suffixes, not bare words, so you might not have even noticed. They both mean “and”, but -vi is used for noun phrases, while -jyn is for verbs. To use them, you suffix them to each head word (noun for -vi, verb for -jyn) except the last one.

And then we have a few regular derivations we can point out:

  • -ölad (alternate form -ëlad) creates “mass” nouns for substances, collections, and things like that.

  • ur- negates adjectives; urburdos “impossible” is the antonym of burdos “possible”.

  • -önda (alternate form -ënda) creates abstract nouns from verbs: sim- “to speak”; simënda “speech”.

Vocabulary
Ardari English
banölad a people
bòte instead of
dabla land
drä then
èlyas heaven
filt- to know as, call by
ghinyas therefore
gwana stone
jan one
jeren there (far)
kamrul- to confuse, garble
kolrach language
kombra tower
kyus so that, because of
lagri word
lòkh whole
märyk- to propose, plan
moki a plain
nyas now
oprös other, otherwise
pamör mortar
pyurys pitch, tar
rejvet- to understand
säll east
sèlokyn mortal
simënda the act of speech
sun same
tapsin- to migrate
tèghdar- to descend
tsor(a/i) a god
tyolta brick
uq- to stop doing
urburdos impossible
utuwe- to scatter
warhan thorough
wizèl- to settle
zhi thus, in this way

Conclusion

So there you have it: the first full text in both Isian and Ardari. I hope you’re playing along at home, and you’re close to making your own translation of the Babel Text (or whatever you prefer).

Starting in the next part, we’ll be filling in the blanks that I had to leave in here. That should keep us occupied for a while. And then we’ll need some more words.

By this time next year, Isian and Ardari should be radically different. It’s my hope that 2017 will open with something far more…intense. By then, our conlangs will be well on their way to general usability. They won’t be complete, mind you, because when can you say a language is complete?

Holidays

This time, I have a much better reason for taking some time off: the holidays. Remember, I write most of my posts beforehand, and the run-up to Christmas has taken its toll on my writing schedule. So I’ll use the lame-duck week between Christmas and New Year’s to take some time for myself, to enjoy all my wonderful gifts (yeah, right; I’m 32 now, I honestly like giving more than receiving these days), and to build up for next year. “Let’s make a language” continues apace, however. The timing for it worked out perfectly, and I had the latest parts done well in advance. (Part 9, for example, was actually written in late October!)

So, have a great week, and I hope you have had a wonderful holiday season, whichever holiday it is that you celebrate. I’ll see you again next week, and next year.

Let’s make a language – Part 10b: Relative clauses (Conlangs)

(Editor’s note: I wrote this two weeks ago. It’s only the calendar that put it out on Christmas Day.)

As I said before, I think relative clauses are hard to wrap your head around. Fortunately, once we know the basics, it’s much easier to put them into a conlang. Let’s do that now, with Isian and Ardari.

Isian relatives

Isian relative clauses always appear at the end of a noun phrase. That one’s pretty much the only non-negotiable part of the nominal grammar. But how do we make them? As it turns out, in one of two different ways, depending on what we’re relativizing.

For subjects, Isian uses a simple gap strategy. The only way you’ll know it’s a relative clause is by a special marker ke that goes before the verb. For example, “the man who saw me” translates as e sam ke cheres men. In a sense, ke functions almost like English that, as a complementizing particle, but it’s more tightly bound to the verb than the noun.

A couple more examples, using only old vocabulary:

  • es esher ke dalega e sush talar “the girls that live in the blue house”
  • ta almerat shes ke barda e ficha shimin “a wise woman who prays at the river”

Everything else that needs to be relativized works differently. (This, by the way, is an example of the accessibility hierarchy in action.) For these, Isian uses a resumptive pronoun. This is just a personal pronoun in the appropriate case and number, and it takes the place of the relativized argument. Changing our first example around, we would have e sam ke chereta im, meaning “the man I saw”. (Literally, this would be “the man I saw him”, which is ungrammatical in English.) Note that ke is still used, but im appears as the object, in a resumptive context.

More examples include:

  • e talar ke dalegan em i ed “the house where I live” (or “the house in which I live”)
  • lichacal ke rococan em ed “everything I have written”
  • es des ke an din fanama des mit “the things we can’t have”

Also, in this type of relative clause, Isian’s normal SVO word order isn’t quite as rigid. Resumptive pronouns can be fronted for emphasis, although they can’t come before ke and the verb. Actually, in these cases, the normal word order almost becomes VSO, with VOS a distinct alternative.

So, that’s the basic outline for Isian relative clauses. Compare that to the length of the last post, and you can see what I mean when I say that they’re hard to understand, but easier to implement. Now, let’s take a look at Ardari.

Ardari relatives

Grammatically speaking, this is one instance where Ardari is actually far simpler than Isian. It uses a full complementizing gap strategy throughout. The relative argument, whether subject, object, oblique, or genitive, is fronted and replaced by qa. The relative clause then slides into the noun phrase just before the head noun.

  • Subject: qa tyèketö wi reje sèdardös, “the children playing in the house”
  • Object: tura qa grätod ènglatö, “the long sword I made”
  • Oblique: qa chès tatyerod astitö, “the friend I danced with”
  • Genitive: sli qa me kyure yfilyod nälitö “the beautiful woman whose hand I held”

Postpositions are fronted, but not replaced, so they’re effectively “dangling”, although it’s impossible to end the sentence with one. (This should cause such a conflict in grammar pedants’ minds that it will shut them down for good.) The last two examples above illustrate this, with the postpositions chès “with” and me “of”; the latter is the way to make an Ardari genitive in a relative clause, since qa doesn’t have case forms. Putting these two in a “standard” form would give us astitö chès tatyerod “I danced with the friend” and slini nälinitö kyure yfilyod “I held the beautiful woman’s hand”, respectively.

Conclusion

There’s not much else to say, really. Again, the hard part is understanding relative clauses enough to know how to put them in your conlang. Putting them in turns out to be almost trivial in comparison. Who would have guessed?

Next time, we’ll look at the “other” kind of relative clause, more properly called the “adverbial” clause. Before that, though, next week will be special. See you next year!

First glance: Unreal.js

With Christmas coming up, I don’t exactly have the time to write those 2,000-word monologues that I’ve been doing. But I want to post something, if only because laziness would intervene otherwise. Inertia would take over, and I’d stop posting anything at all. I know it would happen. I’ve done it once before. So, these last few Wednesdays of 2015 will be short and sweet.

This time around, I want to talk about something I recently found on a wonderful site called Game From Scratch. It’s called Unreal.js, and it’s open-source (Apache license). What does it do? Well, that’s the interesting thing, and that’s what I’m going to ramble on about.

You’ve probably heard of UnrealEngine. It’s the latest iteration of the game engine used to power a wide array of games, from Unreal Tournament to AAA titles like the newest Street Fighter and Tekken to hundreds of up-and-coming indie games. The most recent version, UnrealEngine 4, is getting a lot of press mainly because of its remarkably open development and friendly pricing scheme. (Compared to other professional game engines, anyway.) Lately, Unreal has become a serious competitor to Unity for the middle tier of game development, and competition is an indisputably good thing.

But Unreal has a problem compared to Unity. You see, Unity runs on Microsoft’s .NET framework. (Strictly speaking, it runs on Mono, which is a Microsoft-approved knockoff of .NET that used to be fully open, to the point where most Linux distributions preinstalled it a few years ago. Now…not so much.) Anyway, Unity uses .NET, and one of the nifty things about .NET is that, like the JVM, it’s not restricted to a single language. Sure, you’re most likely to use C#, but you don’t have to. Unity explicitly supports JavaScript, and it used to have full support for a Python clone called Boo. (Supposedly, there are ways to get other languages like F# to work with it, but I don’t know why anyone would want to.)

Unreal, on the other hand, uses C++. From a performance perspective, that’s a great thing. C++ is fast, it can use far less memory than even C#, and it’s closer to the hardware, making it easier to take advantage of platform-specific optimizations. However, C++ is (in my experienced opinion) one of the hardest programming languages to learn well. It’s also fairly ugly. The recent C++11 standard helps a lot with both of these problems, but full support just isn’t there yet, even 4 years later. C++17 looks like it will go a few steps further in the “ease of use” direction, but you’ll be lucky to use it before 2020.

The makers of UnrealEngine know all of this, so they included a “visual” programming language, Blueprints. Great idea, in theory, but there are a lot of languages out there that you don’t need to invent. Why not use one of them? Well, that’s where Unreal.js comes in. Its developers (some guys called NCSoft; you may have heard of them) have made a plugin that connects the V8 JavaScript engine from Chrome/Safari/Node.js/everywhere into Unreal. The whole thing is still in a very early stage, but it’s shaping up to be something interesting.

If Unreal.js takes off, then it can put Unreal well ahead of Unity, even among hobbyists and lower-end indies. JavaScript is a lot easier on the brain than C++ (take it from someone who knows both). And it has a huge following, not just for webapps and server stuff. The Unreal.js project page claims support for “(Full) access to existing javascript libraries via npm, bower, …”

That’s huge. Sure, not all npm packages are of the highest quality, but there are plenty that are, and this would let you use all of them to help make a game. Game engines, historically, have been some of the worst about code reuse, 3rd-party libraries, and other niceties that “normal” applications get to use. Well, that can change.

And then there’s one other factor: other languages. Since Unreal.js is pretty much just the V8 engine from Node, and it can load most Node packages, that opens the possibility of using some of the many “transpiled” languages that are transformed to Node-friendly JavaScript. Think CoffeeScript, TypeScript (which recently released its new 1.7 version), or even my April Fools’ Day joke language Elan.

Maybe I’m wrong. Maybe Unreal.js will fizzle. Perhaps it’s destined to join the legions of other failed attempts at integrating game development with the rest of the programming world. I hope not. The past few years have seen a real move in the direction of democratizing the art of game-making again. I’d like to see that trend continue in 2016 and beyond.