OpenCore Software

Here are some preliminary results from a look at the openplans.org data. I should say that the values are approximate, but I think they should be pretty close to the real values.

Here is what it all means:

mem active - the number of active members that logged in to the site during the previous 30 days

mem avg life - the average number of days a member is active (estimated from all members who are now dormant)

proj active - the number of active projects who have had their wiki edited during the previous 30 days

proj avg life - the average number of days a project is active (estimated from all projects who are now dormant)

ml active - the number of mailing lists which received a post to the archives during the previous 30 days

ml avg life - the average number of days a mailing list is active (estimated from all those that are now dormant)

One thing to note is the sharp drop in active members in November. This is perhaps, in part, due to a migration of members from openplans.org to nycstreets.org. Also, of all the data points, the December value is the one I trust the least due to the way things are approximated. In January I plan on doing a bit of work to verify the accuracy of these estimates.

The mailing list activity is higher than I expected. I checked and made sure that this isn’t due to spam (spam doesn’t actually make it into the archive.)

So this is just the start of what we can do to analyze our usage information to help us make good decisions about the evolution of our software. From here we can go on to analyze Task Tracker and WordPress usage.

Once again, I’d been thinking of making a blog post about what I’m working on (short version: I’m taking a break from REST configuration (I’ll leave the puns as an exercise for the reader) to work on what basically amounts to a server-side optimization for the Vespucci project) but I find myself more interested in this discussion on the OpenCore dev list. I thought about making this post an email to that list, but the comments I’m planning to make are basically tangential to the thread there.

What I take away from that thread is that we the OpenCore developers are planning on making people on openplans.org more like projects, with their own featurelets (mailing lists and task trackers and such) to go along with the wiki that’s currently provided. This seems kind of weird to me; as my understanding is that openplans.org is about projects and making it easy for groups with similar goals to collaborate and share skillsets and experience. It’s not clear to me how letting a person track personal tasks or run a personal blog is helping to accomplish that. Instead, I would think a generalization of my earlier thoughts on blogging would be more appropriate: have tabs on the user account page for each of the available featurelets, but show them as a filter on the entire site rather than unique content. So, the task tracker tab would show only tasks assigned to the user, the mailing lists tab would show threads the user participated in, etc. That would let you see things from a people-oriented point of view without creating this kind of island of content where the user has their own personal stuff on a site that’s supposedly intended to help them share with others.

Of course, I have no idea whether this really makes sense. I often find that ways of doing things that make sense to me are kind of lost on non-developers (like when I bitch to Windows users about how hard it is to change file extensions on their platform and they stare blankly and wonder what possible reason you could have to want to do that). But, I’m not a developer on OpenCore so hopefully my perspective on things isn’t too tainted by elbow grease.

Another thought that occurred to me while thinking about this is that if people are projects, and people can be members of projects, then OpenCore obviously supports having projects as members of projects. This excited me more than a little (being a computer geek, I of course love hierarchies!) I think if that sort of nesting of projects is allowed then you can structure things in a way that makes a lot of sense. For example, you can have an Organization be an entity recognized by openplans.org in the same way that People and Projects currently are. An Organization could probably be nearly identical to a Person, but with some string changes (an organization has a logo, not a photo, and services rather than skills, etc.) Of course you can’t log in as an organization either. Organizations and Projects could have as members People, Projects, or other Organizations (think of local chapters or subdivisions for Organization->Organization, and planning committees for Project->Organization) ), and People wouldn’t be allowed to have any members, of course. The neat thing that I see here is that the membership wouldn’t have to be exclusive; in the same way that People can be members of multiple Projects, Projects could be sponsored by multiple Organizations. Organizations could have multiple parent Organizations as well (like Geoserver could be both a subdivision of TOPP and a member of OpenGIS).

Anyway, like I said I’m not really aware enough of OpenPlans to know whether any of what I said is really applicable. To follow in the recent trend of posts on what success is for openplans, I’d say it’s probably not measured by how well the software models the relationship between people, projects, and organizations But I do think that modeling them well makes it easier to present them in a navigable way (that is, making it easier to find projects that are related in the types of ways our software knows about). If our goal for openplans.org is to bring projects together, then it’s probably a step in the right direction.

What’s our definition of success, our institutional purpose? Personally I have a very clear sign of success in my own mind: how strongly do I recommend our service to other people? I’m a a bit shy about suggesting people use “my” stuff, where “my” means something for which I feel responsible for both in its success and failure (which of course includes openplans.org). If I personally felt confident recommending openplans.org to anyone, especially people who I don’t want to give personal technical support, then I would feel part of a successful project. I’d love it if then a lot of people everywhere used it, but my personal feeling of satisfaction is not contingent on that. Or maybe that’s what my notion of success+1 would become.

What about the development analog: would I recommend our software to other developers (not hosted by us)? Frankly I don’t care much about this. Making our software generally usable I think is an important discipline for us, but to me it’s not an end. Why not? I’m not really sure.

Fun with misleading errors and generator expressions! It took me a couple hours to figure out an error I was getting; here’s a boiled-down version.

First, here’s what’s supposed to happen:

>>> def joiner(tuples):
...     generator = (str(x[0]) for x in tuples)
...     return ' '.join(generator)
...
>>> joiner(((1, 2, 3), (4, 5, 6)))
'1 4'

Now suppose something's gone wrong with the input and it isn't nested:

>>> joiner((1, 2, 3))
Traceback (most recent call last):
  File "", line 1, in ?
  File "", line 3, in joiner
TypeError: sequence expected, generator found

Say what? I'd expect that to give "TypeError:  unsubscriptable object"
because the first time through the generator expression,
you're effectively doing this:

>>> 1[0]
Traceback (most recent call last):
  File "", line 1, in ?
TypeError: unsubscriptable object

 So that’s your real problem, but somewhere else (in str.join i guess?) that gets caught and turned into “sequence expected, generator found”. Ugh. Which is really misleading; you *can* call str.join on a generator as long as the generator returns strings and doesn’t blow up.

This took so long to diagnose because all the code (including the generator) is third-party, and it *usually* worked, and the problem turned out to be triggered by me passing a bad value for a seemingly unrelated string parameter (I failed to capitalize it). And pdb isn’t very useful with generator expressions (I have no idea why the guy was even using one there). And you can’t step into str.join() either since it’s a C function.

Sobering thought for the day… there are two kinds of people: the disabled, and the temporarily abled.

With that in mind: “Degrading gracefully” for non-javascript browsers isn’t just a theoretical nicety. For some people it’s the only way they can use a website at all.

I’m a javascript novice, so I hardly know a lot about the best practices here, but there’s some interesting commentary out there if you google a bit. For example, “Test your pages, you wanker. With assistive technologies. And real disabled people. Or you’re a bigger nob than you look.”

Neither am I an expert on accessibility, disability rights, etc. (but my mother-in-law is).

In a funny way, we’re lucky that our current functional testing technology doesn’t support javascript, because it ensures that things mostly work.  But for a concrete example - the one that prompted this post - can flunc “see” a textarea if you style it as hidden by default? I suspect it doesn’t care about css-driven visibility; all it does is find the element in the document.