CivicApps.org in a nutshell

Back in the old days, i.e. 2008, cities like Portland would create apps (interactive websites) for us like this:

The old way of making apps

They’d get a team together, look at the Datasets available to it, come up with ideas, and then build the apps.  PortlandMaps, an awesome web app, was made this way.  But there’s a new trend and Portland’s setting an example for other cities.  First, the city adopts a policy of transparency, publishing all of its raw data in addition to the finished apps:

First, cities make their raw data available

Then, curious and entrepreneurial individuals, companies, and other organizations step in and independently create new apps.  This frees up city resources and results in more apps and services coming online:

Then, 3rd parties can step in and contribute

This is the entire purpose of the CivicApps.org project and website: to enable this creative environment.  By the way, this is the same idea behind the federal Data.gov project.

My idea: we can contribute data too

It occurred to me that many organizations have valuable data about the city.  And some even have the expertise to publish the data in “open formats” just like the city of Portland is doing:

My idea: We can provide datasets too

For example, my project, OregonLaws.org, publishes a glossary of legal terms specific to Oregon.  This is already up and running as a Dataset.

It will, though, take some work to implement my idea.  Some questions to answer are;  How will these 3rd party Datasets be integrated into the palette of “official” ones?  How will the data be authenticated or verified?

The near future

The end result of all this is that the city could become a nexus of information.  In addition to providing raw data about itself, it can act as a means of identification and authentication. There’s a precedent for the government acting in this role, e.g. the Secretary of State’s business registry performs a similar service.

Update

Oregon Business Magazine covered the CivicApps contest:  Keeping PDX a Hot Spot for App Development

Background context

Subversion uses a single, central repository which is in a remote place. And in your project, it maintains .svn/ directories in every sub-directory. Git on the other hand, gives each developer their own full-fledged repository. And then, instead of relying on many hidden directories in your project, it creates one that lives only in the top-level directory; in .git/. So again: that’s the only place it stores info; nowhere else in your code.

Interesting, huh?

The advantages I’ve found

So now that I’ve begun to use git, it’s already been a nicer experience than subversion:

Deleting a subdirectory doesn’t screw with the versioning like it does in svn.  (Because no version info is stored there.  In svn, you need to repair things; re-create the empty directory so you can delete it, etc.  I do this to myself periodically.)

It’s totally painless to put existing stuff into git — it stays right where it is. E.g., a website that’s in use. You can initialize the repository and commit the current version of the files while they’re in use. This isn’t possible with svn: you have to check it in, then check it out.

It’s easy to work on a new idea: it’s really easy to create a branch to work on it, and then switch back and forth. In svn, this is enough of a pain that I don’t do it in actual practice.  Git finally makes it easy for me to use revision control like I’ve always wanted: be able to check out our group’s code, test ideas out, and rollback in my own little world without disturbing the others, and finally commit only the changes I want to.

Git assumes you meant to delete that file. That’s been nice and convenient:  I deleted a file without going and telling git first about it.  Git adds a ‘delete’ operation to your list of things to check in.  Awesome.  Svn does it the other way around:  You can’t just do normal file operations; you have to also tell subversion that yes, you did mean to do that.

Git has the GitHub killer app. It’s the Netscape of the WWW.  I haven’t found an equivalent for Subversion — web-based or not.

So that’s what I’ve come up so far; I’ll add more when I see them.

I’m releasing a new open source library, HTTP-Assertions, that I use behind the scenes at OregonLaws.org.  It helps me keep the server running smoothly and make sure that my changes to the config files haven’t introduced new bugs.

It introduces these new assert methods to the Rails testing environment:

  assert_200
  assert_forbidden
  assert_temp_redirect_to
  assert_perm_redirect_to

Here’s an example:

  assert_200('https://www.oregonlaws.org/ors/161.360')

See the README on github for more details.

Basically, software should be held to the same standards we have for people, especially in the field of law. Here’s what that might look like. This is, again, the “development” interface… an end-user would see something much fancier:

>> Abbreviation.abbreviate 'Chief Justice'
=> "C.J."
>> Abbreviation.rule
=> "Appendix 3"

It’s a start.

As far as the technical implementation, I’ve been considering rule-based systems, prolog-based systems and object-oriented decomposition.

>> Abbreviation.abbreviate 'Advance'

=> "Adv."

>> Abbreviation.abbreviate 'Advanced'

=> "Adv."

>> Abbreviation.abbreviate 'Advancing'

=> "Advancing"

So, this has been pretty interesting. Now I need to handle plurals well. This, though, means I’ll have to be able to identify plurals… but I have a couple of good ideas about how to do this.