Hacker News new | past | comments | ask | show | jobs | submit login
The Constitution and U.S. Code on GitHub
32 points by laws on Sept 24, 2010 | hide | past | web | favorite | 17 comments
We now have the technology to participate directly (if unofficially) on optimizing the U.S. Constitution and Code. Instead of interacting with the legal system politically, by supporting/opposing archaic human "representatives", let's be hackers and fork the laws. We could first gain an understanding of the legal environment, then beat congress at their own game. The U.S. Code is published every six years; the last ratified amendment to the Constitution was in 1992 (and it was proposed 202 years earlier!). Can we do to Congress what email did to the USPS?

I don't have the time to get it started (plus I'm a total git n00b), but I wanted to throw the idea out there. Maybe others have done something similar, a cursory check on Google didn't return anything though. I registered this "laws" username on GitHub and created stub repos:



I'd be happy to hand over the account if somebody wants it. Anyone interested?

Not sure how useful this is for existing laws, but for pending legislation it would be fascinating to see the forks and merges as lawmakers negotiate toward a final bill. Maybe the Sunlight folks are doing something like this?

From http://marc.info/?l=git&m=128077393712932&w=2

I'd figured to play with Git in an unusual way: to create a repository for the U.S. Constitution where amendments are presented as patches.

What follows is an interesting discussion of getting git to represent the dates correctly. :)

Hmmm... what we need is a virtual US on which to test changes to laws.


this a great scientific fiction novel SIMULACRON - 3; 1964). Autor: DANIEL F. GALOUYE

that deals with that subject,

also Maze of Death by PKD touch similar isues

I thought about doing this a few months ago and tried to register gitlaw.com but that domain was already taken (but inactive). Looks like someone else had the idea too.

However, I not only wanted to put the current US Constitution and Code into git, but every version going back to 1776. What an amazing data source that would make, to be able to see all revisions and additions to the US legal code since inception, how it grew and changed over time. The data visualizers could have a field day.

However, that's a massive project, and I'm not sure if all that data even exists in portable electronic format, or just the recent versions of the Constitution and US Law.

It's still in the back of my mind and if I figure out a way to do it I'll probably revisit it.

Interesting hack. I'll point out a couple things you may not have thought of though:

1. The U.S. legal system is designed to go slowly. That's what checks and balances are for. It takes a long time to see the full implications of each law (look what happened when Glass-Steagall was repealed), and if the laws change every day, you can end up whipsawing with no idea what really works or not.

2. How will the laws be evaluated? In the U.S, you have judicial review, where cases come before the courts, the facts come out into the open, a jury of your peers evaluates how the law applies to those facts, and then the appellate court system ensures the law was applied correctly. If the law is egregiously wrong, there's widespread publicity and then public pressure to amend the law. How does this same sort of fact-based discovery process factor into your system, and how do you avoid it devolving into a "he said she said" contest of differing opinions?

3. How will you get public buy-in? Democracy's based upon the consent of the governed; when everybody writes their own version of the laws, each person could make the argument that they didn't consent to the other person's version.

4. It seems like this would replace plutocracy (government by the rich and well-connected) with technocracy (government by the quick-thinking and technically savvy). As a technocrat, I'm all in favor of that. ;-) But it seems like you're just exchanging one set of masters for another, and in many ways, this new system is less fair than the old one. What happens to the 95% of Americans who are not accustomed to thinking at Internet speed? They're already being left out in the cold by many economic developments; will you exclude them from the political process too?

1. Maybe state laws would be a better place to start. It's more plausible that a hacker could get into a state house/senate/gubernatorial position and elicit change at a local level. Also, there's potentially more room for refactoring than feature changes.

2. The same way software commits or Wikipedia edits are evaluated. Discussion and voting. As with OSS and Wikipedia, few would actually propose changes, but it's better than the current system (which is closer to the model of proprietary software and traditional encyclopedias).

3. As ry's node is the official Node.js, "usgov" would host the legally binding repo, and individuals would simply have their own non-binding forks. Congress's role would shift to primarily merging in pull requests.

4. I imagine most aren't interested in proposing laws any more than they are in editing Wikipedia. But everyone would benefit from a more succinct, optimized legal structure, as they do from a better source of information.

This is all really beside what I had in mind though. I don't think there's much point trying to do anything official, in cooperation with the current government. The way you improve Windows is by building a better operating system, not directly trying to change Windows.

Haha - I'd totally like to see fully annotated, backdated diffs for each revision--also known as amendments (starting with the Bill of Rights)--and branches and merges for each HR/SR (by accounts that represent who authored said resolutions), and forks for countries whose constitution was based on the US.

That network graph would be AWESOME.

I think it would be more interesting to use github to devise a better language for law.

It could try to find a way to allow more specificity with less verbosity, and provide a standard way of creating abstractions that would allow for easy checking of conflicting definitions. Maybe even include a comment system for stating the intentions at time of writing, which could be taken into account when modifying the code.

I applaud what you're trying to do, but it may be a tad idealistic. The US is filled with legacy code, and there are lots of vested interests in keeping it the complicated way. As programmers we are trained to be purely logical, but politics and governance is 99% emotion, 1% logic.

The first step in changing something is being able to understand it, and the first step in understanding it is to have it organized. The organizational component that is missing is, to put it in terms we at HN deal with everyday, to generate Changelogs and revision history (with attribution, down to the politician).

It would be nice to have all changes, including proposed changes, documented in a relatively easy to navigate format. Git, or any modern SCM, may qualify as a tool to provide that. Some of the most important metadata about proposed changes, even if they don't get included in the final, passed laws, would exist on branches; metadata like who proposed it and who signed off on it, who supports it. If anything, this would make The Daily Show's researchers' job easier.

While politics is 99% emotion, those emotions should include motivation, not frustration experienced early on when trying to grok the system. In a free society, the output of the governance should be accessible to all. One can debate if git is accessible, but it would definitely be a format that is more accessible, and maybe even more machine processable, than the current system.

Perhaps MediaWiki (or similar) would be a better choice. The (incomplete) U.S. Code is up on WikiSource (http://en.wikisource.org/wiki/United_States_Code).

I actually prefer source code revision system more than wiki. Wikis are chaos. People can still fork your code, and submit pull requests. Moderation is still required.

Maybe you're right. This would be like trying to carve out an optimal Lisp with CL as one's starting point. A better approach might be to begin with the Constitution (as pg did with McCarthy's original paper) and "restart the kind of [legal] design" the founders were "doing at the point where [they] left off." (http://www.paulgraham.com/core.html)

Politics and governance maybe, but not law. The text of law actually shows remarkable statistical resemblance to code, since fundamentally it does something similar and has to be just as explicit in its methods. http://radar.oreilly.com/archives/2007/08/code-looks-like.ht...

Why isn't the text on github yet, it just says "Nothing to see here yet. Move along."

Applications are open for YC Summer 2020

Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact