Legal Markup Language

Today at work, I had to sign some legal papers. They were pretty standard “I have read the attached policy and agree to be bound by it” stuff that all of us Full-Time Employment Units have to sign once a year.

But I’m the sort of person who believes that if I sign an agreement, I ought to at least know what it says. But I have better things to do than to read legalese all day.

The same problem applies to a lot of commercial applications: every time you upgrade, you have to agree to a EULA for the new version. For a variety of reasons, most people just click through and get on with their lives. But it would be nice to be able to know that the vendor hasn’t just asked you to sign over your firstborn.

One possible solution would be a markup and revision system for legal documents. For starters, if your job requires you to sign an Acceptable Behavior Policy once a year, you could read it carefully once when you sign on, and save a copy. Then, the next year, you can compare the version you’re given with the one you signed a year ago. If there are no changes, you can just sign it without reading, on the grounds that if you didn’t have a problem with it last year, you don’t have a problem with it now.

Of course, a lot of documents include other documents by reference. These need to be archived as well.

It would also be nice to add comments: for instance, if the policy requires you to keep your cell phone number on file with your manager so that you can be contacted outsiide of business hours, you could add “Has my cell phone changed since last year?” in the comment area.

Since big chunks of legal documents are just boilerplate text, and since many legal documents (such as software EULAs, credit card applications, car rental agreements, etc.) apply to many people, it would be nice to look them up on the net. That is, the tool on your desktop could take the MD5 hash of a clause, send that off to the legal opinion servers of your choice, and see what they have to say. For instance, the EFF could have a repository that says that certain clauses aren’t as scary as they sound; the FSF could point out which clauses will forfeit your Free Software-loving soul.

This could be a commercial service: you could pay a legal firm for online legal advice. Yes, a lawyer would have to read and research the various documents, and that’s expensive; but if they can spread the cost around several hundred or thousand clients, it could become affordable.

You should be able to specify certain details about your situation. For example, a clause that affects US Government employees might be either important or irrelevant, depending on whether you’re a fed or not. You should be able to check or uncheck “I work for the US government” in the preferences menu, so that the software will look up the appropriate response. Ditto if you don’t work at a nuclear reactor, don’t deal in foreign trade, and so forth.

One interesting aspect of this is the coding theory aspect of it: there’s a level of distrust that has to be dealt with. If you sign the yearly policy without reading it because it hasn’t changed since last year, then you probably don’t want to leave your copy of last year’s document with your employer, in case they try to change it. And if you leave a copy on your employer’s computer, they might not be above rooting around in your files to change your backup to make it match this year’s version. So you’ll want to be able to cryptographically sign each document. And of course any sensitive information that goes out on the net needs to be encrypted.

Then there’s the question of giving away information by the sorts of questions you ask. For instance, you may not want the people running Joe Random Legal Server to know that you work for the military or at a nuclear power plant, but there are common clauses that affect people who do. So while the program on your desktop needs to know this in order to give you good advice, that’s not necessarily something you need to send out on the net. So when it sends out a query about a particular clause, the protocol should allow to specify as much or as little detail as you want: if you say that you don’t deal in trade with foreign nationals, the remote server can save itself the trouble of looking up what a given clause means for those who do; but if you don’t say whether you’re in the military, it’ll send both responses back and let your desktop software decide which version to show you.

Of course, you probably don’t mind letting your attorneys know whether you’re in the military, so the software should be smart enough to send this information only to some servers and not others.

I imagine that some of this already exists: contracts are already negotiated between parties that don’t trust each other. Presumably the law firms on each side already have software that’ll tell them that section 3, paragraph 10 hasn’t changed since the last round of negotiations, so they don’t need to check it again.

And of course laws go through many iterations from original inception to bill to committee to floor vote, and are often amended by people of other parties, who’d love to make life miserable for you. The staffs of legislators must have some system for keeping track of it all. Hopefully some of it is automated.

For software, there are already software-installation tools that include presenting a EULA to the user as a standard step. It shouldn’t be too hard to put in a hook that calls the user’s preferred legal document management system.

Subversion version control system has a “blame” subcommand that shows you when certain lines in a file were last changed, and by whom. Legalese is so structured and formal that it seems that a similar approach should be able to help there as well.

Teasing Information Out of Noise

Humanist Symposium

Bennett Haselton has an interesting
at Slashdot about how to develop a “scientific” test for child

Given that Slashdot is all about technology and gadgets and stuff, you
might expect the article to describe a new image-recognition algorithm
or something, and wonder how it could possibly work on such a
subjective problem. But he doesn’t; in his proposal, the
“measurement”, if you will, consists of people looking at photos that
may or may not be illegal pornography.

In other words, the problem is that we don’t have a good
scientific instrument that we can point at a photo and have a red
light go on if it’s illegal pornography. All we have is people, who
have to make a judgment call as to whether a given photo is legal or

One problem with this is that we’re asking people to make a subjective
judgment call. And that means they’re likely to get the wrong answer.

So Haselton’s approach is to use people as his instrument, then say
okay, we know that this instrument is unreliable; let’s find out under
which circumstances this instrument fails, and try to counter that.

For instance (he claims), you can take a given photo, mix it in with a
bunch of others that are illegal, and people will condemn the whole
set. But you can then mix the same photo with a bunch of innocent
photos, and people will declare the whole set legal. This tells us
that our instrument is a) unreliable (a photo can’t be legal and
illegal at the same time), and b) affected by context. He then proposes ways to work around this problem.

What I found interesting about this article is that Haselton tries to
apply the scientific method to a highly-subjective area. A lot of
people think science is about labs and test tubes and computer models
and such. But as I’ve argued
the hardware is secondary, and the core of the scientific method
is really a mindset, and asking the questions “what is the world
like?” and “how do I know this isn’t garbage?”

The other remarkable thing about this article is that it demonstrates
how to tease information out of noise: you have witnesses making
subjective judgment calls on an emotionally-charged subject, biased
prosecutors, biased defenders, and fuzzy legal guidelines. You might
be tempted to throw up your hands and declare that under these
conditions it’s impossible for justice to be served reliably. And yet,
he takes the optimistic approach that no, we can serve
justice, or at least improve our odds of getting the right answer.

It’s a bit like John Gordon’s
summary of coding theory
(aka the biography of Alice and Bob):

Now most people in Alice’s position would give up. Not Alice. She has courage which can only be described as awesome.

Against all odds, over a noisy telephone line, tapped by the tax authorities and the secret police, Alice will happily attempt, with someone she doesn’t trust, whom she cannot hear clearly, and who is probably someone else, to fiddle her tax returns and to organise a coup d’etat, while at the same time minimising the cost of the phone call.

A coding theorist is someone who doesn’t think Alice is crazy.

I often hear that such-and-such problem can’t be approached
scientifically (morality, the existence of God, beauty, whether
something is pornographic or obscene, etc.). A lot of times, though,
it’s because people either haven’t bothered to see how far a
scientific or rational approach can take them, or else they’re unaware
of how much can be done with such an approach, or how
simple it can be. (The reason I don’t make a big deal of whether a
restaurant serves Coke or Pepsi is that my brother and I once tried a taste
test, and I found that I couldn’t really tell them apart.)

It’s also awe-inspiring to think about how far we’ve come, as a
species: not only have we improved our instruments — from naked
eyes to Galileo’s telescope to Hubble — but through statistical
methods, experimental design, and others, we’ve increased the amount
of information we can glean from existing instruments.

Not bad for a bunch of naked apes with oversized brains and a knack
for cooperation.