Category: Thoughts

Social Liberty: Rights and Responsibilities

The following are some of the founding rights of Social Liberty, as set out by the Principle of Initial Conditions. Each is then given its own commentary regarding how it fits within the system and why it was chosen.

Right of Free Expression — All persons have the right to express in spoken, written, and published forms any truthful or opinionated statement not intended to cause direct harm to another, whether alone or with others.

This is a restatement of part of the First Amendment, covering freedom of speech and the press together with the right to assemble. “Direct” harm is intentional: words have no power to physically hurt, but they can incite others to do so.

Right of Faith — All persons have the right to practice their own faith without interference from a citizen or government.

This one covers the Establishment Clause part of the First, as well as most other “freedom of religion” aspects. Note that something like a cult where members are poisoned, or the rape and slavery practiced by ISIS, are not protected under the Right of Faith; allowing those violates the higher Principle of Purpose, as a government must endeavor to keep its citizenry safe.

Right of Arms — All persons are permitted to own and bear personal arms intended for their own defense.

Your basic Second Amendment, but written more clearly. Also, there’s no room for a comma splice to change the meaning.

Right to Privacy — No agent of government may observe or search a person without a warrant obtained under reasonable suspicion that a crime has been committed, nor may an agent of government seize any of a person’s property unless that person has been charged with a crime.

Definition of Agent of Government — An agent of government, in regards to the Right to Privacy, is any person working directly subordinate to the state for purposes of defense, security, or law enforcement, or granted such status by another agent.

Here’s your Fourth, with the usual search-and-seizure stuff. “Observe” includes wiretaps, too, and you can see how it also covers the Third Amendment.

Right to Criminal Trial — A person charged with committing a crime must be allowed a fair trial, by a jury if that person so chooses, without undue delay, and the person must be given sufficient opportunity to present a defense of the charges.

Standard Sixth with this one, plus a requirement that the court allow a proper defense. No “freeze their assets so they can’t pay a lawyer” trickery here.

Right to Civil Trial — When two people are in dispute regarding a debt or infringement of rights, either party may request a judicial hearing or jury trial to settle that dispute.

This one’s the Seventh Amendment, often forgotten in our time of binding arbitration. Arbitration, as a private matter, is not part of Social Liberty. Only the use of it in place of a court is within the government’s purview.

Right to Petition — Any person may petition the government, through a trial by an impartial arbiter or jury of citizens, to redress a perceived violation of that person’s rights.

This one’s actually part of the First Amendment (“petition the government for a redress of grievances”), but it’s put here so it falls with the other “trial” Rights. Effectively, it is the right to sue the government if it is breaching your rights. As with the others, the wronged party has the right to choose a hearing or jury trial.

Right to Freedom of Person — No person may be forced by another to work without proper compensation.

Definition of Proper Compensation — Proper compensation, in regards to the Right to Freedom of Person, consists of monetary pay, tangible benefits, and status or rank as befits the work performed.

Slavery, technically, is forbidden by the Principle of Purpose, but this restates it as a Right, roughly equivalent to the Thirteenth Amendment. The definition also subtly invokes minimum wage, “wage gaps” (via the Principle of Equality), and things like insurance benefits.

Right to Vote — All able citizens are permitted to vote on matters of government representation and public petitions, and no action may be taken by another to deprive a person of this right.

Responsibility Of Voting — An able citizen must vote in representative elections or on balloted matters of local or state import, unless this would cause undue hardship or duress.

Definition of Able Citizen — Regarding the Right to Vote and the Responsibility of Voting, an able citizen is a person above the age of majority who is of sound mind.

Voting rights are mentioned in quite a few amendments to the US Constitution: the 15th, 19th, 24th, and 26th are all concerned with opening up the vote to more people. Social Liberty dispenses with all that; every adult who is capable of doing so not only can vote, but must vote. In other words, it’s more like Australia, where everyone is both automatically registered and required to vote in elections. Also, ballot measures are enshrined here as an important part of the political process.

These are not the only rights granted by the Doctrine of Social Liberty, but they are some of the most notable. For the most part, they flow logically from the Principle of Initial Conditions, sometimes affected by the other Principles. And they are rights that, when stated in this form, should be universally agreed upon. Nothing in them prefers or promotes a specific political agenda, except the general notion of greater liberty for all.

Social Liberty: Definitions

First, let us call the fundametnal properties of good government the Principles. These are so central to the idea of Social Liberty that they literally cannot be violated within its framework. A Principle is inviolate by definition, for changing it would change the nature of the space. Principles are thus axiomatic; the six I have chosen define the very concept of Social Liberty.

Second, a Right is a property taken to be inherent to the system. It cannot be abridged, violated, or removed except by another Right or as punishment. Rights in Social Liberty include many of those taken to be inalienable and self-evident, such as freedom of expression, freedom of religion, the right to bear arms, and the right to a trial. A new right can be created, as described by the Principle of Evolution, in a manner dependent upon the system of government.

Third, a Law may be defined as a requirement that must be followed by the citizens of a state. Laws may not be written to directly infringe Rights, but they may define the boundaries of those Rights, and violation of a Law may cause Rights to be lost temporarily. In addition, Laws may be used to clarify cases where two different Rights are in conflict. For example, a Law cannot revoke a Right of Free Speech, but it is allowed to spell out those instances where that Right is overruled by a Right of Privacy.

Fourth, a Responsibility is a duty impressed upon citizens as part of the social contract they form with their government. Laws may bring about Responsibilities, but these may not permanently deprive a citizen of a Right. Responsibilities may also arise logically from Principles; these Responsibilities may violate Laws and limit Rights.

Fifth, a Privilege is subordinate to a Law. It is a lesser right created by the interaction of Laws and Rights, and it may be removed by either. New Rights are rare, but new Privileges may be invented more rapidly, under the Principle of Evolution.

Finally, let us define a Definition as a clarification of the meaning of a word as it is used in the text of a Right, Responsibility, Law, or Privilege.

The Doctrine of Social Liberty is made up of these Principles, Rights, Responsibilities, Laws, and Definitions. They are written in plain language, because understanding the principles of one’s state is necessary for a citizen. Each is given a name for easier reference, as in this example:

Right of Arms — All persons are permitted to own and bear personal arms intended for their own defense.

In later Laws or other text, this can be referred to simply as “the Right of Arms”. For example:

Law of Disallowed Weapons — Any weapon capable of killing multiple people with a single shot, or requiring the operation of more than one person, shall not be considered a personal arm under the Right of Arms.

With these definitions, we are able to construct the structure necessary to create a nation-state that fulfills the goals of Social Liberty.

On procedural generation

One of my favorite uses of code is to create things. It always has been. When I was young, I was fascinated by fractals and terrain generators and the like. The whole idea of making the code to make something else always appealed to me. Now, as it turns out, the rest of the world has come to the same conclusion.

Procedural generation is all the rage in games these days. Minecraft, of course, has made a killing off of creating worlds from nothing. No Man’s Sky may have flopped, but you can’t fault its ambition: not only was it supposed to have procedurally-generated worlds, but a whole galaxy full of aliens, quests, and, well, content. That last part didn’t happen, but not because of impossibility. The list goes on—and back, as Elite, with its eight galaxies full of procedural star systems, is about as old as I am.

Terrain

Procedural terrain is probably the most widely known form of generation. Even if you’ve never played with TerraGen or something like that, you’ve probably played or seen a game that used procedural heightmaps. (Or voxels, like Minecraft.) Making terrain from code is embarrassingly easy, and I intend to do a post in the near future about it.

From the initial generation, you can add in lots of little extras. Multiple passes, possibly using different algorithms or parameters, give a more lifelike world. Tweaking, say, the sea level changes your jagged mountain range into an archipelago. You can go even further, adding in simulated plate tectonics or volcanic deposition or coastline erosion. There really are no boundaries, but realism takes some work.

Textures and models

Most 3D modeling software will give you an option to make “procedural” textures. These can be cool and trippy, especially those based on noise functions, but it’s very difficult to use them to make something realistic. That doesn’t stop them from being useful for other things; a noise bump map might be more interesting than a noise texture, but the principle is the same.

Going one step up—to actual procedural models—is…not trivial. The “creature generators” as in No Man’s Sky or Spore are severely limited in what they can do. That’s because making models is hard work already. Leaving the job in the hands of an algorithm is asking for disaster. You’re usually better off doing as they do, taking a “base” and altering it algorithmically, but in known ways.

Sound

Procedural sound effects and music interest me a lot. I like music, I like code. It seems only natural to want to combine the two. And there are procedural audio packages out there. Making them sound melodic is like getting a procedural model to work, but for your ears instead of your eyes. It’s far from easy. And most procedural music tends to sound either very loopy and repetitive, or utterly listless. The generating algorithms we use aren’t really suited for musical structure.

Story

Now here’s an intriguing notion: what if algorithms could write a story for us? Creating something coherent is at the high end of the difficulty curve, but that hasn’t stopped some from trying. There’s even a NaNoWriMo-like contest for it.

On a smaller scale, games have been making side quests and algorithmic NPCs for years. That part isn’t solved, but it isn’t hard. (For some reason, Fallout 4 got a lot of press for its “radiant quests” in 2015, like it was something new. Though those are, I think, more random than procedural…) Like modeling, the easiest method is to fill in parts of a pre-arranged skeleton, a bit like Mad Libs.

Anything else

Really, there’s no limit to what can be made through procedural generation. That’s probably why I like it so much. From a small starting seed and a collection of algorithms, amazing things can be brought forth. In an age of multi-gigabyte games full of motion-captured animation, professional voice talent, and real-world scenery, it’s a refreshing change to make something beautiful out of a few letters and numbers.

The alternative

No form of government is perfect. If one were, every nation-state would eventually gravitate towards it. Nor will I say that I have developed the perfect form of rule. In fact, I’m not sure such a thing is possible. However, I can present an alternative to the deeply flawed systems of the present day.

Guided by the principles of good government we have previously seen, and aided by logic, reason, and the wisdom of ages, we can derive a new method, a better method. It is not a fully-formed system. Rather, it is a framework with which we can tinker and adjust. It is a doctrine, what I call the Doctrine of Social Liberty.

I cannot accept the strictures of current political movements. In my eyes, they all fail at some point. That is the reason for stating my principles. Those are the core beliefs I hold, generalized into something that can apply to any nation, any state. A government that does not follow those principles is one that fails to represent me. I am a realist; as I said above, nothing is perfect. Yet we should strive for perfection, despite it being ever unattainable. The Doctrine of Social Liberty is my step in that direction.

More than ever, we need a sensible, rational government based on sound fundamentals. The answer does not lie in slavishly following the dogmatic manifestos of radical movements. It does not lie in constant partisan bickering. It can only be found by taking a step back, by asking ourselves what it is that we want from that which governs us.

Over the coming weeks, I hope to detail what I want from a government. I don’t normally post on Tuesdays, but the coming election presents a suitable reason to do so. In four posts, I will describe my doctrine in its broadest strokes, and I will show how our current ruling class violates the principles I have laid out. Afterward, following the start of next year, I want to go into greater detail, because I think these things will become even more relevant.

On visual programming

With the recent release of Godot 2.1, the engine’s developers broke the news of a project coming to a future version: a visual scripting system. That’s nothing new, even in the world of game development. Unreal came out with Blueprints a while back, and even Godot already used something similar for its shaders. Elsewhere, “visual programming” has its proponents and detractors, and I’m going to throw in my two cents.

Seeing is believing

In theory, visual programming is the greatest revolution in coding since functions. It’s supposed to deliver all the benefits of writing programs to those who don’t want to, well, write. The practice has its origins in flowcharts, which are graphical representations of algorithms. Computer scientists got to thinking, “Okay, so we can make algorithms like this, so why not whole applications?” It’s only been fairly recently that computers have been able to fulfill this desire, but visual programming languages are now springing up everywhere.

The idea is deceptive in its simplicity. Instead of laboriously typing out function declarations and loop bodies, you drag and drop boxes (or other shapes), connecting them to show the flow of logic through your program. The output of one function can be “wired” to another’s input, for example. The benefits are obvious. Forget about syntax errors. Never worry about type mismatches again. Code can truly become art. With the name of this site, you’d think I could get behind that.

It does work, I’ll give you that. MIT’s Scratch is used by tens of thousands of programmers, young and old alike. Through its ingenious “building block” system, where the “boxes” are shaped like pieces in a jigsaw puzzle, you never have to worry about putting the wrong peg into the wrong hole. For children who barely understand how a computer works—or, in extreme cases, may not know how to read yet—it’s a great help. There’s a reason why it’s been copied and cloned to no end. It even makes coding fun.

What can’t be unseen

The downsides to visual programming, however, are not fun at all. Ask anyone who’s ever suffered through LabVIEW (I’ve read enough horror stories to keep me away from it forever). Yes, the boxes and blocks are cute, but complex logic is bad enough when it’s in linear, written form. Converted to a more visual format, you see a literal interpretation of the term “spaghetti code”. Imagine how hard it was to write. Now imagine how hard it would be to maintain.

Second, visual programming interfaces have often suffered from a lack of operations. If you wanted to do something that there isn’t a block for, you were most likely out of luck. Today, it’s not so bad. Unreal’s Blueprints, for example, gives you about 95% of the functionality of C++, and Godot’s variation purports to do the same.

But some things just don’t fit. Composition, an important part of programming, is really, really hard to get right visually. Functional styles look like tangled messes. Numerics and statistics are better served in a linear form, where they’re close to the mathematics they’re implementing.

The verdict

I’m not saying visual programming is useless. It’s not. There are cases where it’s a wonderful thing. It’s great for education, and it’s suited to illustrating the way an algorithm works, something that often gets lost in the noise of code. But it needs to be used sparingly. I wouldn’t write an operating system or device driver in Scratch, even if I could. (You can’t, by the way.)

In truth, the visual “style” doesn’t appeal to me. That’s a personal opinion. Your mileage may vary. When I’m learning something new, it’s certainly a big help, but we have to take the training wheels off eventually. Right now, that’s how I see a visual scripting system. For a new programmer, sure, give it a try. You might love it.

But you probably won’t. After a while, you’ll start bumping into the limitations. You’ll have webs of logic that make spiders jealous, or customized blocks that look like something by Escher. Stay simple, and you might keep your sanity—as much as any programmer has, anyway. But we’re not artists. Not in that way, at least. Code can be beautiful without being graphical.

Let’s end threads

Today’s computers almost all have multiple cores. I don’t even think you can buy a single-core processor anymore, at least not one meant for a desktop. More cores means more things can run at once, as we know, and there are two ways we can take advantage of that. One is easy: run more programs. In a multi-core system, you can have one core running the program you’re using right now, another running a background task, and two more ready in case you need them. And that’s great, although you do have the problem of only one set of memory, one hard drive, etc. You can’t really parallelize those.

The second option uses the additional cores to run different parts of a single application. Threads are the usual way of doing this, though they’ve been around far longer than multi-core processors. They’re more of a general concurrency framework. Put a long-running section of code in its own thread, and the OS will make sure it runs. It won’t block the rest of the program. And that’s great, too. Anything that lets us fully utilize this amazing hardware we have is a good thing, right?

Well, no. Threads are undoubtedly useful. We really couldn’t make modern software without them. But I would argue that we, as higher-level programmers, don’t need them. For an application developer, the very existence of threads should be an implementation detail in the same vein as small string optimizations or reference counting. Here’s why I think this.

Threads are low-level

The thread is a low-level construct. That cannot be denied. It’s closer to the operating system layer than the application layer. If you’re working at those lower levels, then that’s what you want, but most developers aren’t doing that. In a general desktop program or mobile app, threads aren’t abstract enough.

To put it another way: C++ bears the brunt of coders’ ire at its “manual” memory management. Unlike C# or Java, a C++ programmer does need to understand the lifecycle of data, when it is constructed and destructed, what happens when it changes hands. But few complain about keeping track of a thread’s lifecycle, which is essentially the same problem.

Manual threading is error-prone

This comes from threads being low-level because, as any programmer will tell you, the lower you are in the “stack”, the more likely you’ll unwittingly create bugs. And there might not be any bigger source of bugs in multithreaded applications than in the threading itself.

Especially in C++, but by no means unheard of in higher-level languages, threading leads to all sorts of undefined or ill-defined behavior, race conditions, and seemingly random bugginess. Because threads are scheduled by the OS, they’re out of your control. You don’t know what’s executing when. End a thread too early, for example, and your main program could try reading data that’s no longer there. And that can be awfully hard to detect with a debugger, since the very act of running something in debug mode will change the timing, the scheduling.

Sharing state sucks

In an ideal situation, one that the FP types tell us we should all strive for, one section of code won’t depend on any state from any other. If that’s the case, then you’ll never have a problem with memory accesses between threads, because there won’t be any.

We code in the real world, however, and the pure-functional approach simply does not work everywhere. But the alternative—accessing data living in one thread from another—is a minefield full of semaphores and mutexes and the like. It’s so bad that processors have implemented “atomic” memory access instructions just for this purpose, but they’re no magic bullet.

Once again, this is a function of threads being “primitive”. They’re manually operated, with all the baggage that entails. In fact, just about every problem with threads boils down to that same thing. So then the question becomes: can we fix it?

A better way

Absolutely. Some programming languages are already doing this, offering a full set of async utilities. Generally, these are higher-level functions, objects, and libraries that hide the workhorse threads behind abstractions. That is, of course, a very good thing for those of us using that higher level, those who don’t want to be bogged down in the minutiae of threading.

The details differ between languages, but the usual idea is that a program will want to run some sort of a “task” in the background, possibly providing data to it at initialization, or perhaps later, and receiving other data as a result. In other words, an async task is little more than a function that just happens to run on a different thread, but we don’t have to care about that last part. And that is the key. We don’t want to worry about how a thread is run, when it returns, and so on. All we care about is that it does what we ask it to, or else it lets us know that it can’t.

This async style can cover most of the other thread-based problems, too. Async tasks only run what they’re asked, they end when they’re done, and they give us ways (e.g., futures) to wait for their results before we try to use them. They take care of the entire lifecycle of threading, which we can then treat as a black box. Sharing memory is a bit harder, as we still need to guard against race conditions, but it can mostly be automated with atomic access controls.

A message-passing system like Scala and Erlang use can even go beyond this, effectively isolating the different tasks to an extent resembling that of the pure-FP style. But even in, say, C++, we can get rid of most direct uses of threads, just like C++11 removed most of the need for raw pointers.

On the application level, in 2016, there’s no reason a programmer should have to worry about manual memory allocation, so why should we worry about manual thread allocation? There are better ways for both. Let’s use them.

On sign languages

Conlangs are, well, constructed languages. For the vast majority of people, a language is written and spoken, so creators of conlangs naturally gravitate towards those forms. But there is another kind of language that does not involve the written word, does not require speech. I’m talking, of course, about sign language.

Signing is not limited to the deaf. We all use body language and gesture every day, from waving goodbye to blowing kisses to holding out a thumbs-up or peace sign. Some of these signs are codified as part of a culture, and a few can be quite specific to a subculture, such as the “hook ’em horns” gesture that is a common symbol of the University of Texas.

Another example of non-deaf signing is the hand signals used by, for example, military and police units. These can be so complex that they become their own little jargon. They’re not full sign languages, but they work a bit like a pidgin, taking in only the minimum amount of vocabulary required for communication.

It’s only within the community of the hearing-impaired that sign language comes into its own, because we’re talking about a large subset of the population with few other options for that communication necessary for human civilization. But what a job they have done. American Sign Language is a complex, fully-formed language, one that is taught in schools, one learned by children the same as any spoken tongue.

Conlangs come in

So speaking with ones body is not only entirely possible, but it’s also an integral part of speaking for many people. (The whole part, for some.) Where does the art of constructing languages come in? Can we make a sign conlang?

Of course we can. ASL was constructed, as are many of the other world sign languages. All of them have a relatively short history, in fact, especially when compared to the antiquity of some natural languages. But there are a few major caveats.

First, sign languages are much more difficult to comprehend, at least for those of us who have never used one. Imagine trying to develop a conlang when you can’t speak any natlang. You won’t get very far. It’s the same way for a non-signer who would want to create a sign language. Only by knowing at least one language (preferably more) can you begin to understand what’s possible, what’s likely, and what’s common.

Second, sign languages are extremely hard to describe in print. ASL has transcription schemes, but they’re…not exactly optimal. Your best bet for detailing a sign conlang might actually be videos.

Finally, a non-spoken, non-written language will necessarily have a much smaller audience. Few Americans know ASL on even the most rudimentary level. I certainly don’t, despite decades of alphabet handouts from local charities and a vain attempt by my Spanish teacher in high school to use signing as a mnemonic device. Fewer still would want to learn a sign language with even less use. (Conlangers in general, on the other hand, would probably be as intrigued as for any new project.)

Limits

If you do want to try your hand at a sign conlang, I’m not sure how helpful I can be. I’ll try to give a few pointers, but remember what I said above: I’m not the best person to ask.

One thing to keep in mind is that the human body has limits. Also, the eye might be the most important organ for signing. A sign that can’t be seen is no better than a word you don’t speak. Similarly, it’s visual perception that will determine how subtle a signing movement can be. This is broadly analogous to the difference in phonemes, but it’s not exactly the same.

Something else to think about: signing involves more than the hands. Yes, the position and orientation of the hands and fingers are a fair bit of information, but sign languages use much more than that. They also involve, among other things, facial expressions and posture. A wink or a nod could as easily be a “phoneme” of sign as an outstretched thumb.

Grammar is another area where signing can feel strange to those used to spoken language. ASL, for example, doesn’t follow normal English grammar to the letter. And there’s no real reason why it should. It’s a different language, after all. And the “3D” nature of sign opens up many possibilities that wouldn’t work in linear speech. Again, it’s really hard to give more specific advice here, but if you do learn a sign language, you’ll see what I’m saying. (Ugh. Sorry about the pun.)

Celebrating differences

Conlanging is art. Just as some artists work with paint and canvas, others sculpture or verse, not all conlangers have to be tied to the spoken and written varieties of language. It’s okay to be different, and sign languages are certainly different.

Elimination

The six basic principles of responsible government don’t, by themselves, converge on a single system. Instead, it’s best to first look at those regimes they entirely eliminate.

Necessity

Egalitarianism is, in essence, a lack of organized government. Anarchy is a repudiation of it. Neither is well-suited to the needs of a large, diverse state. Human nature is to be social, and that means forming relationships, whether romantic, platonic, friendly, or simply on the basis of mutual acquaintance. Those relationships can easily turn into alliances, recognitions of shared purpose. From there, it is a short step to self-organization, and then to government. Therefore, anarchy can never be more than merely a temporary state.

Purpose

A government that does not protect the lives of its citizens is a failure. One that does not uphold those citizens’ rights is equally lacking, though the nature and quantity of those rights can be argued. It is clear, however, that some systems of rule are entirely unsuitable. Those predicated on the absence of individuality—Leninist communism, for instance—cannot be considered acceptable for governing a free people. Likewise, those which ignore fundamental human rights—theocracies being only the most familiar example—must not be seen as viable. But even democracy is not infallible, as the tyranny of the majority can be used to strip rights from the minority. Good government, in this sense, is far more than a question of who rules. It also must take into account how those who rule protect those who do not.

Evolution

Nothing in this world is without change, and that includes society. Social mores shift over generations, but a rigid government can fail because it fails to adapt to these seismic shifts. To prevent this, a state must give some allowance to the possibility of radical changes to its structure, to its core tenets. Those that do not, those that remain fixed, are doomed to fall. Again, theocracy, with its strict insistence on dogma and received wisdom, is the perfect illustration. But a theocracy can adapt by reading and interpreting its scriptures in a new light, while a strongly segmented, highly conservative aristocracy may instead resist the natural evolution of culture, leading to failure.

Equality

Every human being is unique, but we all share many things in common. It is easy, common, and perfectly natural to separate humanity into groups based on the presence or absence of a specific factor. However, to institutionalize this separation is to create an imbalance between members of a preferred class and outsiders. Implementing this sort of segregation by intrinsic factors, those we are physically, mentally, or psychologically unable to change, sorts humanity into those who are—by definition—haves and have-nots. This leaves a segment of the population without political power, without the opportunity for redress, and that segment will only seek to find a new outlet for such. Legislative tribalism, in the form of laws motivated by race, religion, sex, or other factors, is a failure of a government to protect (as by the Principle of Purpose) a certain portion of its citizenry. Executive tribalism, as seen in caste systems, aristocracies, communism, and oligarchy, bars this same portion from using its political voice.

Cooperation

Once again, we return to egalitarianism, as it is a prime example of the nature of competition. When every man is for himself, he can accomplish only what is within his own means. A larger conglomeration, however, can achieve greater things. This is because of resource pooling, specialization, and leadership, among other factors, and it is an expected consequence of our social nature. The most striking examples are those grand projects requiring the cooperation of an entire state, but this sort of socialism is inherent in any system of government. That does not require a surrender of all free will, as in Hobbes’ Leviathan, nor is it a condemnation of capitalism. When we accept the role of government, we commit a portion of ourselves to it, hoping that we receive greater benefits in return. It is this equation, in its lack of balance, where the failure of neoliberal technocracy lies. Yet there is equal imbalance in pure objectivism and pure collectivism.

Initial Conditions

The final principle is the most culture-specific, and it is here that one government system—or the idealized notion thereof—is singled out. However, the Constitution itself does not uphold all the ideals stated above. In its original form, it embraced inequality. It made little space for grand-scale cooperation. In accordance with the Principle of Evolution, however, it has changed to reflect the times, the changing beliefs of those it represents. Other founding documents fail a different set of fundamental principles, and in differing ways. They may be suitable as a starting point for deriving a system of government, but few begin so close to the ideal. Wholly unusable, by contrast, are scriptural resources such as the Ten Commandments, as these are defined by their violation of the Principle of Equality.

None of this is to say that these forms of government are invalid. If a people chooses to create for itself a state based on a violation of the Principles, the choice is theirs alone, and it is not for us to assign fault or blame. Those regimes, however, may not endure.

On game jams

This post is going up in August, and that’s the month for the summer version of everyone’s favorite game jam, Ludum Dare. But I’m writing this at the end of June, when there’s still a bit of drama regarding whether the competition will even take place. If it does, then that’s great. If not, well, that’s too bad. Neither outcome affects the substance of this text.

Ludum Dare isn’t the only game jam on the market, anyway. It’s just the most popular. But all of them have a few things in common. They’re competitive programming, in the sense of writing a program that follows certain rules (such as a theme) in a certain time—two or three days, for example, or a week—with the results being judged and winners declared. In this, it’s a little more serious than something like NaNoWriMo.

And it’s not for me. Now, that’s just my opinion. I’m not saying game jams are a bad thing in general, nor am I casting aspersions at LD in particular. I simply don’t feel that something like this fits my coding style. It’s the same thing with NaNoWriMo, actually. I’ve never truly “competed” in it, though I have followed along with the “write 50,000 words in November” guideline. Again, that’s because it’s not my style.

One reason is shyness. I don’t want people to see my unfinished work. I’m afraid of what they’d say. Another reason is the schedule, and that’s far more of a factor for a three-day game jam than a month-long writing exercise. I don’t think I could stand to code for the better part of 48 or 72 hours. Call it flightiness or a poor attention span, but I can’t code (or write) for hours on end. I have to take a break and do something else for a while.

Finally, there are the rules themselves. I don’t like rules intruding on my creative expression. In my view, trying to direct art of any kind is a waste of time. I have my own ideas and themes, thank you very much. All I need from you is the gentle nudge to get me to put them into action. That’s why I do a kind of “shadow” NaNoWriMo, instead of participating in the “real thing”. It seems antisocial, but I feel it’s a better use of my time and effort. What’s important is the goal you set for yourself. Climbing into a straitjacket to achieve it just doesn’t appeal to me.

But I do see why others look at game jams differently. They are that nudge, that impetus that helps us overcome our writing (or coding) inertia. And that is a noble enough purpose. I doubt I’ll join the next Ludum Dare or whatever, but I won’t begrudge the existence of the game jam. It does what it needs to do: it gets people to express themselves. It gets them to write code when they otherwise wouldn’t dare. There’s nothing bad about that, even if it isn’t my thing.

Conlangs as passwords

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

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

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

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

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

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

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

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

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

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

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