I was doing some trademark research at the firm I’m clerking at, and found just what I was looking for: a particular abandoned trademark registration. I wanted to send a partner an email about it, and so I mistakenly did the natural thing: I copied and pasted the URL (the link) to the USPTO web page.
He replied a few minutes later: the link wouldn’t work. They never do; they expire after 10 minutes or so. And so what happens? Attorneys print out or create PDFs of the USPTO web pages in order to discuss them.
I immediately thought that there must be something that could be done here, and so I started the Trademark Permalink project:
Create links that don’t expire to trademarks at the U.S. Patent & Trademark Office. Use them in emails, on your website, or anywhere else you want to point someone to a trade/service-mark registration.
EDIT:
The story’s gotten a little more complicated: In the past day or so, I discovered that it’s possible that my work might be superfluous: The “TARR” USPTO web app provides single-document retrieval via URLs that don’t time out. Many (most?) practitioners seem to only know about the TESS service, though, which *does* time out. Also, the TARR data seems to come from a different source, and is definitely a different format. For example, the IBM registration I use as an example:
http://tarr.uspto.gov/servlet/tarr?regser=serial&entry=75871833
Think 200 is a web experiment that combines web server configuration with one of the best programming practices: test-driven development. It works with Apache, Nginx, IIS, or any other web server. The new idea goes like this:
- You find a web page that’s not returning the status code or results you wanted it to (i.e. redirecting to the wrong place).
- You write a test (which will fail) which “asserts” the behavior you want it to have.
- You edit your config files, periodically re-running all of the tests.
- When all of the tests pass, your job is done.
The same benefits of TDD should apply to TDC.
CivicApps and the Search for Ideas
I just found out that I won one of the two Best Idea awards given in the first annual CivicApps for Greater Portland contest; I was completely surprised and very honored. My idea is Community-Contributed Datasets.
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
Why “git” instead of “svn”?
As I learn git, I’m experiencing advantages that I haven’t seen described together. Also, I haven’t seen a description from the perspective of the real-world differences in your files, so here goes:
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.
