[OSM-talk] The future of bugs in OSM

[SteveC]

I've been thinking a bit about how bugs work in OSM.

I really like the way OSB works

	http://openstreetbugs.appspot.com/

But it's closed source afaik and doesn't have an API. It uses human  
input. new OSB is cool and tries to fix some of this

	http://wiki.openstreetmap.org/wiki/User:Emka/new_OSB

I like keepright

	http://keepright.ipax.at/

But it's more automated.

Here's my vision for how bugs should work.

You go to http://bugs.openstreetmap.org/

There's a big map of bugs which looks similar to OSB. It doesn't know  
who you are and drops you in to beginner mode which shows bugs that  
are relevant to you - human entered stuff say. There is an  
intermediate mode which shows a slide which, when slid, shows more  
bugs. So at the low end human entered stuff, but at the high you get  
every single fixme from OSM. Then there is expert mode which looks  
like keepright, and you can click various things on and off.

How do you enter bugs? There are two ways. As a human on bugs.osm.. www.openstreetmap.org 
  you can click a little green plus like OSB has on the map, or  
potlatch will let you do it too.

But, and this is key, it also has a RESTful API for mass uploading of  
bugs.

We need to do two things - unify the various bug systems and expose  
more of the bugs.

To give you an example there are tons of bugs in the US, but there is  
no systematic way to fix them, or even begin fixing them. There are  
some good HOWTOs on the wiki on the actual individual details of how  
to fix a bridge connected to the road beneath it, but no big list of  
such bridges or where they are. We need to make this systematic.

	http://wiki.openstreetmap.org/wiki/TIGER_fixup/Over_Connectedness

Why is my system better than OSB or keepright?

OSB with a simple API might fly, but it's not open and not quite part  
of OSM. Keepright kind of gets there but the barrier to entry is high.  
If I want to do an import and list bugs to check, or I want to write  
my own little maplint utility to check for X or Y or Z I have to learn  
whatever language keepright is in and start hacking against a large  
codebase. Instead, bugs.openstreetmap.org would offer a really simple  
REST api to throw bugs at.

I envisage it as a sort of clearing house for bugs. It will quickly  
become very useful for lots of people writing small, loosly-joined  
tools. The barrier to me writing a small bug app is low. I imagine all  
sorts of little apps writing things to submit bugs much as keepright  
or maplint sort of do now. All they have to do, is run a script to  
report the bugs from planet every week (or whatever) and keep track of  
the bug IDs and see if they're closed yet.

Now on the output side I think there is a huge amount of potential.

Right now people don't know where to start fixing things. You can  
point people at OSB but that is human only, or you could point them at  
keepright or maplint but then you have to fight to maintain those  
things. Instead, bugs.openstreetmap.org would be a central clearing  
house which everyone can submit to and use.

To go back to that example, if someone writes a script to find all  
freeways in the USA which connect at right angles to residential roads  
and submits them through the api to bugs.openstreetmap.org then you  
have a big dataset. It becomes super fun, cool and easy to motivate  
the community and say - hey lets fix all those bugs in the US. You can  
draw graphs of the number of bugs being eaten up, show progress, make  
a leaderboard... all the things that will motivate a *lot* of people  
to fix these things. It will be so cool to be able to have many people  
working on closing bugs, I'd make it my number one slide in every talk  
I go to, saying "go to bugs.openstreetmap.org and enter or fix a bug"  
maybe I should already with OSB.

Now, you can of course just write a standalone app to do that freeways  
in the US a bit like keepright is a standalone app, but having it work  
for that, then someone else enters all the bugs in Spain that they're  
interested in, someone else when they import the next GNIS or  
something, adds bugs against all the imported PoIs that they need to  
be checked, other people can just enter bugs they see.... it becomes a  
very powerful system. All it needs is a little REST api.

And what's doubly great is that it's basically a weekend, if that,  
project to get started and do the simplest pieces. Then we can iterate  
it from there.

Thoughts?

Best

Steve