Work stuff.
To those who responded to my plea for help by leaving a comment or responding out-of-band, thank you very much. We’ve settled on a name for our application, purchased the corresponding domain names and filed a trade mark application.
Will keep you posted as things evolve further. But just to give you an idea, we’ve already iterated through several “alpha” versions and expect to have a public beta ready by the end of February. Stay tuned for an explanation of what the service actually does.
For anyone who’s using Subversion through Textmate, you might be interest in Ciarán Walsh’s SVNMate plugin. It changes the icons for files and folders in the project drawer depending upon their SVN status. Very handy.
Valued readers, would you be so kind as to lend 15 seconds of your time completing the following task for me, your humble host. I ask that, from among the five names below (which, for various reasons, all begin with the word “cite”), you choose the one name that you believe sounds the best. The one that rolls off your tongue most easily. The one that you think is, well, coolest. Please do not bother yourself with trying to guess the meaning of the name, or the purpose of this exercise (though many of you will no doubt have a good idea). I am after your immediate gut feeling response. Please leave your response as a comment on this post.
I would be more than grateful if you could point your friends and colleagues at this blog entry, particularly if they are involved in writing research manuscripts.
Thank you!
TextMate seems to be recommended by just about every Mac-oriented programming site out there. So I bought it a few weeks ago. For 33.15 EUR. It rocks. Oh, and this post was made from within TextMate.
In another piece of NICTA news, on Thursday Queensland Premier Anna Bligh announced that the state government will invest $10.05 million in NICTA’s Queensland Research Laboratory over the next four years. Here’s an interesting tidbit from the Australian IT news article:
Technologies developed by NICTA’s Queensland facility are widely used by the state government. One example is software to authenticate and protect digital evidence currently deployed by the state’s police force.
To be honest, “widely used” might be a bit of a stretch at this point, but it’s true that the state’s police force are using the mentioned piece of software and they’re very keen on it. I’d be willing to bet that the next four years of the lab will be pretty successful in terms of spin-outs, licenses and other outcomes.
NICTA has a very different atmosphere to DSTC (which I can’t imagine will ever be surpassed in my career in terms of outright coolness) and Sun Labs, two places I’ve worked before and which I give credit to for inspiring me along the path to a career in research, so it took a while to get used to. I guess it’s still trying to find its own culture, really. The Queensland lab may be helped on in that respect by the cozy confines of our new quarters at UQ (at the very least, we’ll all get to know each other very well!). NICTA as a whole has set pretty high standards for itself, particularly in terms of research project approvals, and to its credit, recent evidence tells me that it’s going to do its best to keep to those standards. I hope it does.
As of Monday, NICTA’s Queensland Research Lab will be located at UQ. Here’s the address:
Queensland Research Laboratory
Level 5, Axon Building (47),
Staff House Road,
St Lucia Qld 4072
PO Box 6020,
St Lucia QLD 4067
It’s probably time to come clean about my recent spate of posts on startups, Ruby, Python and so on. Well, there are a few things about peer review and publishing in the realm of academia that I think could be better, so I tried to figure out an alternative process that retains the benefits and overcomes some of the problems of the current system. We think we’ve done that, and it turns out that I wasn’t the only one who thought that things could be a lot better.
NICTA has provided pre-seed funding in the form of a couple of commercialisation grants to implement this new way of doing things. I’ve hired a top notch graduate software engineer (who’s been working with me as a student for the past year and a half on unrelated things) to help me deliver alpha and beta versions of this system over the next six months or so. For this project, we’ll be working in startup mode; I’ll be making every effort to provide a small company atmosphere for the engineer and others who join the project.
It turns out the solution to the problem can also be applied to (web) search, since it is essentially a nice way of ranking documents within communities. I can’t go into the details of the solution here, but I can list some of the things that I (and other researchers, as it happens) think could be better.
These are some of the problems that researchers say they can see with the current way of doing things. We think we can claim that our idea solves many of these problems. For example, under our system, which we are calling PubRes for the moment, citation collusion is futile. Under PubRes, you’d also be silly to lend support to a paper that you know isn’t very good (even if it is written by a colleague), and you’d be silly not to lend support to a good paper (even if it is written by a competing group of scientists or your worst enemy). There are some things we haven’t solved, like honorary authorship and ghost authorship, but these are problems I’d like to investigate in the future. Although I can’t reveal the details here, I can say that the underlying mechanics of PubRes are no more complicated than traditional peer review procedures (and probably much less complicated), but it is a major departure from how things are done now. I can also say that the feedback we’ve got from people we’ve explained it to has been overwhelmingly positive, which is the main reason I’m still pursuing this.
NICTA are making sure we do this properly, so some of the grant money is being spent on figuring out the structure of the academic publishing market. We already know that the top three academic publishers had combined 2007 revenues in excess of $US3 billion, but that doesn’t say much. We’re currently doing some much deeper market research to get a better understanding of the domain.
It’s important to note that what we’re doing is completely different to all known attempts to bring science to the web. PubRes is not another CiteULike or Connotea. It’s not another arXiv.org. It’s not like PLoS One or PubMed Central. It’s different to ResearchGATE and Science Commons. While our implementation may contain elements of these existing tools, PubRes is a fundamentally new way of getting your research published, and it’s a new, much fairer (we think), more direct way of rating scientists and the papers that they write. One of our aims is also to make the whole reviewing, publishing and reading cycle a lot more fun.
With any luck, a public beta will be available early next year. Oh, we think we’ve settled on Ruby and Ruby on Rails for the web tier, and no doubt there’ll be some AJAX stuff in there to pull off a few nifty browser side features we have in mind. Stay tuned.
I’ve got some time to work on the context manager today, and I’m listening to some stuff as I code. Here’s a sample:
Also check out The Get Out Clause and this video. It was made by requesting CCTV footage through the Freedom of Information act (apparently).
Update: Here’s the “Paper” video clip inline:
When you’ve spent years coding pretty much everything in Java, it’s hard to break out of the Java way of doing things. It means that you tend to forget that other languages might have things called closures, for example. Here’s how a closure looks in Python:
lambda x:dosomethingto(x,anothervariable)
The neat thing is that this closure can be passed around like a first class object. Also, anothervariable, bound in the outer scope, is accessible to the lambda expression when it is invoked later. You can do stuff like:
if isinstance(somevalue, int) or isinstance(somevalue, float):
isfunny=lambda x:log(x)>somevalue
else:
isfunny=lambda x:isalpha(x) and islower(x)
funnyitems=[item for item in mylist if isfunny(item)]
seriousitems=[item for item in mylist if not isfunny(item)]
Sure there are other ways to do the same thing. But this is arguably more elegant.
There’s also nested functions, which are kind of like closures. Rather than contriving an example, I’ll give one from the book I’m reading, Programming Collective Intelligence. In chapter 8, a crossvalidation function is defined. Forgetting the specifics and purpose of this function, just know that the crossvalidate function returns low numbers for good solutions and high numbers for bad solutions. Earlier in the book, we’d already been introduced to optimisation problems and cost functions. The cost functions take a single argument, which is a potential solution to be costed. The crossvalidate function takes a bunch of parameters, so for this and other reasons it can’t be used directly. But you can do something like this:
def createcostfunction(algf, data):
def costf(scale):
sdata=rescale(data,scale)
return crossvalidate(algf,sdata,trials=10)
return costf
So now your costf function knows about algf and data, despite not having them as parameters. That is, the bound variables to algf and data are available to costf when it is called at some later time:
costf=createcostfunction(knearest,mydata)
annealingoptimise(wdomain,costf,step=2)
So when annealingoptimise eventually invokes costf, costf has access to knearest and data. That is the bindings of algf to knearest and data to mydata live on after the execution of createcostfunction completes. Cool.
Big companies will slowly suck the life out of you. That’s one way of summarising Paul Graham‘s latest essay. To maximise your freedom, he says, join a start-up or start one yourself. It’s a theory that I find very appealing.