The Squirrels Are Watching

High Level Government

Almost all computer programs, at some level, break down into patterns of 1s and 0s. Of course, most programmers no longer program in binary anymore. We instead rely on higher level languages, that is, computer programming languages that abstract from the basic manipulations of 1s and 0s. So instead of punching a hole in the metaphorical punch card, I might just say something like “IF X, THEN Y”.

One of the trends in programming is to move to even higher level languages — that is, to building abstractions on top of the original abstractions. You can write new computer languages using older languages, and so long as the new language meets conditions that make it Turing Complete, you can do everything with the new language that the old one did. The Ruby programming language is written in C which compiles into Assembly Language which in turn breaks down into Machine Code.

Every time you add in another language layer, performance takes a hit. Why? Well, code written in the newer layer needs to be interpreted or compiled down to code understandable to the lower layers. If you had a lot of time on your hand, you could rewrite the higher level languages to eliminate many of the layers of abstraction, but frankly, that’d be a pain in the ass.

So why use higher level languages? Well, mostly, it’s because it’s easier to program in. It allows you to think of your programs in terms of abstraction and metaphors while letting the language’s interpreter / compiler deal with figuring out how to translate that into 1s and 0s. You can also adjust the syntax of the language to remove little annoyances you don’t like (e.g. the Ruby language greatly reduces the need for semi-colons and parentheses in your code). Yes, you lose efficiency, but sometimes waste can be good.

However, the title of this post is “High Level Government”, not “High Level Programming”. Why this little exposition on programming languages then? Well, as law school professors studying the Internet are fond of saying, code is law, that is, computer code regulates human behavior online in much the same fashion that legal code regulates human behavior in societies governed by the rule of law. Based on that metaphor, I’d like to suggest that just as computer programming languages use abstraction to trade efficiency for simplicity and ease of use, forms of governance will also be abstracted to make a similar trade.

In fact, it’s been happening already for quite some time. Just as almost all computer code boils down to 1s and 0s, almost all government boils down to beating people with sticks. The first “government” was probably a caveman named Og threatening to beat up all the other cave people who didn’t listen to him. Overtime, this government evolved. Og threatened to have other cavemen beat you with sticks if you didn’t listen. Og called himself Hammurabi and write down the explicit conditions under which he would beat you with a stick. Og let the other cave people decide what the I-will-beat-you-with-a-stick conditions would be. Og traded his wooden stick for a metal stick that spat out hot lead death. And so on.

We introduced concepts such as rule of law, taxation, democracy, and the judiciary into government, but at its core, government, for the most part, still depends on the use of force. All we’ve done is build abstractions on top of this core idea — the use of force — and abstractions on top of abstractions. The system has, in some senses, become less efficient — the IRS threatening to take to court if you don’t pay your taxes is much slower and less effective than a mobster threatening to bash your head in with a baseball bat if you don’t pay up, but these abstractions make it easier to build larger and more complex systems (e.g. try building a national tax system based around mobsters).

Government is becoming increasingly abstract. So what? Well, I suspect you’ve already put some thought into it if you’ve managed to read this far, but I’ll throw some specifics:

1) Democracy, as we know it, is not the pinnacle of human governance

Programming languages have evolved over time to take advantage of increased computing power. What makes a programming language good today may not meet the demands of tomorrow. Likewise, changes in global economics, cultural integration, the environment, and a whole bunch of other things loosely tied to technological and scientific progress are going to necessitate changes in how we govern.

We Americans like to pretend that the government we invented with the Constitution two hundred odd years ago was mostly perfect, but in reality, it’s rearranged itself quite a bit. Women and non-whites can now vote, the federal government is a gajillion times larger and most everyone pays a somewhat absurd income tax. What has remained somewhat constant are the basic ideas though — equality, representation, rule of law. I’d liken this to certain concepts in programming languages — e.g. encapsulation, inheritance, and polymorphism — that many programmers consider to be Good, although it’s worth noting that there is often significant debate about whether these ideas actually are good, especially depending on the circumstances.

2) Government becomes more easily accessible

The other day, I was having lunch with a bunch of high school friends when one of them started pitching an idea he had for a new startup. The problem was, of course, that he didn’t know how to do any of the coding necessary for this. At this point, he asked if he could quickly learn to create a web application using Ruby on Rails, which he had heard was easy to learn and let you create web applications in minutes. Having spent seven or eight months using Rails, I believe that claim to be greatly exaggerated. None of the current programming languages are to the point where a complete amateur, with zero programming experience, can create anything useful, nor do I think we’ll get to something like that in the neat future — that is, it will be a long time before we can create Maroon.

That said, programming has become increasingly egalitarian. Once the domain of military scientists, programming is now open to millions of hobbyists. Those programmer have, in turn, built more limited abstractions that allow the general online public to do some cool stuff — e.g. you can create your own blog in minutes, even if you don’t know how to make said blog automatically post a new lolcat every Friday.

Likewise, government is becoming increasingly egalitarian. It used to be that in order to establish a government, you had to have a big stick and know how to use it. Now, it’s become a lot more open to ordinary people. There is of course, voting, but there are a lot of other ways in which citizens command government power. Any lawyer can, for instance, formulate a bunch on contracts that regulate the behavior of those who sign it. Those contracts are backed, implicitly, by the government’s agreement to use force to enforce them, just as lower-level programming languages make the higher ones work. Now, you no longer have to be a caveman with a stick or a powerful politician to get people to do stuff — you just need 3 years of law school.

I predict that this is going to become increasingly simplified as time goes on. We’ll keep throwing more abstractions on top until we eventually enable the average person to create legal systems and means of governing people’s behavior without direct intervention from the lawyer of the government. Let’s say, for instance, that I was making an online game with its own virtual currency. Currently, getting users to obey any regulations on how to use that virtual currency requires making your online code force such behavior (a digital “stick”) and an army of lawyers to back your regulations with the government’s “stick”. Just as changes to coding languages are making it easier for people to write code regulating virtual currency usage, I expect changes to our legal code that will make it easier for people to make their own contracts and regulatory agreements.

3. Domain Specific Governments

One nice thing about high level programming languages is that they allow programmers to delve into topics specific to what they’re interested in. With a lower level languages, getting the screen to say “hello world” was a triumph. Now, it’s just a single line of code. You can instead focus on, say, artificial intelligence, rather than making sure the computer knew how to print out a line of text on the screen. It allows amateur programmers to focus on things they care about that the professional programmers working for large corporations or the military might not — e.g. a free online photo sharing site.
Similarly, with a lot of the basic enforcement mechanism simplified, citizens are going to try to create governments — or government like objects — for domains for which they’re interested in. We’ve already seen lawyers craft laws and contracts for just about every imaginable area — there are environmental laws, business laws, technology laws, and so forth. As this becomes more easily accessible however, I believe ordinary people are going to write laws for specific domains that professional lawyers and politicians just don’t have any interest in — e.g. student governments could have a legally binding ruling that prohibited their students from wearing paraphernalia of a rival school without any assistance from the lawyers.

Tags: government, high level government, programming, rambling