Tag Archives: uni

Vale John Hunter, author of Matplotlib

In my BSc(Hons) thesis, which I submitted in 2010, I commenced the acknowledgements as follows:

First, a hearty thanks to people whom I do not know: The developers of Python, Numpy, Scipy, the Python Imaging Library, Matplotlib, Weka, and OpenCV; you have collectively saved me much boring work throughout this past year, for which I am truly grateful.”

So to hear of the sudden death of John Hunter, creator and maintainer of Matplotlib was truly saddening. Matplotlib is one of those pieces of software absolutely instrumental in Python’s takeup as a language in the fields of maths, the sciences and engineering. When I was a student, I’d find myself using Matplotlib very often — it was the best there is.

Tragically, John Hunter was in his mid-forties, and left behind a wife, and three young daughters. Numfocus has created a memorial fund to care for and educate his daughters. I’ll be contributing to this fund as a way of thanking the Hunter family for John’s contribution to my own work.

Fernando Perez of IPython fame has written up a substantial post about John’s contribution to the community. PSF member, and PyCon US chair, Jesse Noller has also written a tribute to John.

It’s a somewhat strange feeling — coming to realise the contribution of one person only after he died. Such is the way of Open Source — the impact of the tools we use and develop become more important than the people who develop them. And sometimes, developers are just happy to let things be that way.

BSc(Hons) Graduation mk.3

On Monday, I had the wonderful opportunity to walk through my third graduation ceremony for what is effectively the same degree! So a bit on how that happened, maybe?

UTAS Graduation, December 2010

Well, I completed my Bachelor of Science with Honours degree in June, from which I graduated with First Class Honours in August. Just on two weeks ago, I received a further letter, suggesting that I attend another graduation to collect a University Medal. The University Medal is the highest award that can be awarded to an Undergraduate Student at the University of Tasmania, and my friend Josh Deprez did an exceedingly thorough writeup of the dimensions etc of the Medal itself when he won his last year.

I note with some amusement the comment that I wrote on that post:

Hmmm. Not so convinced I want to aim for a uni medal now. Really really worrying about the number of opportunities the dean would get to mispronounce my name.

Luckily for me, they paid attention to this and solved the problem by awarding two other Medals in the same ceremony (one to a Maths/Physics student, Paul Stack; the other to my colleague from Computer Science, Theo Wadsley, both of whom thoroughly deserved their awards). This resulted in the script detailed in Josh’s post being altered to something resembling:


Naturally, my name still needed to be read out, so I made the requisite alteration to my card in the hope of something resembling the correct pronunciation appearing (this is primarily due to the Dean at my BSc graduation in 2009 pronouncing my surname as ‘Nee-ge-boa’):


The result wasn’t that bad (Something along the lines of ‘Neu-bauer’, which I’ll accept as a pass :D).

Since Josh’s graduation last year, they’ve made slight variations to the process of handing out Testamurs, instead of having blank scrolls handed out, the testamurs are now handed out in envelopes at the ceremony. In this case, like every other student, I was handed an envelope reading “Your Graduation Certificate”, bearing a large UTAS Lion on it. Unlike every other student, mine did not contain a testamur (I collected mine at my proper graduation in August), but instead a blank piece of cardboard — this naturally led to jokes about the worth of my degree…

Finally, here’s a photo of me with the medal, and its obverse, just in case you were at all interested:


Academia, gogo!

In today’s exciting post I describe a rather amusing series of events and the end result of it:

The events:

  • In August I submitted a paper to a Computer Vision conference being held in New Zealand in November. This is entirely sensible because my honours research received a first-class grade and was in the field of computer vision.
  • In September, a large earthquake occurred in the Christchurch region, causing much pandemonium amongst organisers of said conference.
  • On Tuesday this week, my paper got accepted. Naturally, the conference was organised by people in Christchurch, and they were disrupted by several weeks due to the earthquake.

So the conference is on November 8 and 9 in Queenstown, New Zealand; this leaves me just over two weeks to:

  1. Arrange travel
  2. Revise the paper based upon reviewers’ comments
  3. Prepare a poster to present at the conference
  4. Get there


Honours Etc

Ooops, I appear to have forgotten to update my blog (as usual), and forgot to mention anything at all about my Thesis or my Honours work otherwise for the past four months. I truly can’t be bothered writing about it at the moment, so I’ll just mention that I submitted it a couple of weeks ago, and that I received a mark of First Class for it. I’m pretty happy about that.

More news at 11!

Summer of Etc!

Once again, I’ve left this site for faaaaar too long without letting you all know what I’ve been up to of late (oops). Needless to say, a fair bit has happened in the past few weeks, and it’s probably worth telling you all about this.

Honours, Semester 1 (during semester 2)

Uni study’s been going quite swimmingly of late: both my units of study went pretty well (insofar as I got HDs in them); thesis on the other hand, has only really just started to take off. My research is into the computer vision task fo object detection (for example, finding faces in images), in particular, I’m working on improving the scheme built into the Intel OpenCV Library (Haar Classifier Cascades, if you’re at all interested) by having them consider colour.

One of the deficiencies I’ve discovered during my research is lack of sufficient real-world colour face datasets to perform detection upon: whilst I need in the order of 2000 faces (1000 to train upon, 1000 to test upon), the largest useful academic set is an order of magnitude smaller. For this reason I’m developing my own set. My current intention is to assemble the data set entirely from Creative Commons-licensed data (e.g. from Flickr and Wikipedia) and to release the resultant set under CC licenses too. I expect I’ll give a lightning talk at LCA on this, I’ll also dump a blog post here somewhere about what sort of data I’d like donated.

Summer of Google

One thing that’s looking like it will derail my Honours work slightly happened not too long ago. I applied for a Software Engineering Internship at Google Sydney back in July, and didn’t hear much about it. In late October, however, I very suddenly got contacted about it, and interviewed for the position, and quite happily, I was offered a job. This, amongst other things, involved dropping (almost*) everything for the summer, and moving to Sydney within two weeks, which I guess I’ve done somewhat successfully.

So I’m now working at Google until sometime during the first two weeks of semester (!). My current project involves working on [redacted], to make [redacted] do [redacted]; in related news, the new Sydney offices are pretty damn cool, the food is excellent, and the work is fun. I’m really looking forward to the rest of my time here.

*I guess the most important thing to mention here is that I’m still spending my week-and-a-bit in Wellington for Linux.conf.au 2010, and that I’ll still be running the Open Programming Languages Miniconf there. I can hardly wait!

3 birds…

Let’s kill two birds with one picture, as it were…

Point 1? I got an Honours scholarship. Yay me! Secondly? I got my final mark today (for Functional Analysis), a very satisfying 95 (better than my previous marks for the semester by a long way). This means that I now officially have sufficient credit to graduate to a Bachelor of Science (though this is mostly a formality, I’ve been doing Honours study for two weeks now), and will do so in two weeks time. Awesome!

The third bird? My Honours thesis topic has been allocated. Put as vaguely as possible, it’s about augmenting a machine learning-based object detection system (for images) to use colour images instead of black and white. My supervisor is Mike (my ACM-ICPC coach, as it were). I’ll _try_ and explain it better once I’ve done a bit more reading than I have so far…

Normal service to be resumed later,


More Thingies!

Time for another status report on things that have happened recently!

More Uni!

First up, I’ve started on my Honours year! Isn’t that exciting? As I’ve learnt this week, the next 12 months for me will consist of 4 coursework units, and a research thesis. This semester, it looks like I’ll be studying Embedded Systems (yay! I get to program some microprocessors! Whoo!), Computing in Context (a research-intensive unit in HCI), and possibly one other, depensive on what the unit outline for it looks like. My thesis I’m not so sure about, given that the process by which we get assigned supervisors hasn’t occurred yet. Currently, I have a pile of 12 project areas for my perusal, from which I must rank 6 proposals by order of how much I want to study them. At the moment, there are some interesting-looking proposals relating to Machine Learning, and some interesting ones relating to web monitoring; I find out what I’ve been assigned by Friday (very exciting, no?).

Linux.conf.au 2010

Linux.conf.au 2010 is being held in Wellington, New Zealand. One of the things that makes LCA a truly wonderful conference is the first two days, devoted to single-day “miniconfs” on topic areas of interest to the Free and Open Source Software communities. I’m currently involved with two proposals; I’m primary proposer of a developers’ miniconf (called “Open Languages”) aimed towards uniting the developer communities of open source programming languages, and I’m secondary proposer of an education-flavoured miniconf. I’d be equally happy if either of these proposals get up, but with 30 other awesome proposals competing for 12 openings for miniconfs, there’s going to be some very stiff competition.


Hey, turns out I turned 21 on Wednesday. How did I manage that?


After a somewhat self-enforced marathon exams session, I finished my last (and arguably most difficult) exam on Monday, that was for Functional Analysis, and my first results came out this morning: 3 HD marks and a Distinction, not quite as good as my excellent run of last year, but still not dreadful either. Given that I’ve passed everything, it means that I’ve finished the undergrad component of my degree! Hurrah!

Graduation is in early August, but before then, the Honours programme starts Friday, after only three days worth of holidays. Excellent!

What? Where did the last 2 months go?

Well, somehow we’ve made it to the end of the first semester of this year, and I quite inconveniently forgot to write about anything since the start of April. This is quite problematic. I guess that means it’s time for me to do my semi-regular dump of notable things. Bleh.

So, where to begin?


So yes, we did arrive safely in Germany, spending a week with my relatives who live just outside of Frankfurt-am-Main in centre of the country. That was a fun week, we spent many days taking in the area, sampling the culture, and preparing for the programming contest the next week. We spent a week in Stockholm, where the contest was held, which was great fun in general (despite being somewhat colder than Germany and indeed Australia), we met many like-minded people, and thoroughly enjoyed the week. In the end, we solved three problems in the contest, which was (just) sufficient to see us getting a ranked position of equal 49th (yay!).

I’ll write up the two weeks spent overseas in greater detail soon (hopefully).

Twitter & Co.

So I succumbed to peer pressure roughly two weeks ago, signing up for Twitter and Identi.ca. As a fun experiment into the field, I investigated how long it would take, and what measures would be necessary, for someone to notice that I was on Twitter, and then follow me. I did this by following one or two people per day, and getting them to drop relatively silent hints about my existence. In the end, it took about a week for someone to notice me, with a fairly blatant reference to me needed to make it obvious. Despite the great scientific breakthrough observed, I don’t think the result is sufficient to write a paper about… 😛

My main observation is that Twitter is miles behind Identi.ca in terms of useful features (I like group notices, denoted by ‘!’ tags in Identi.ca, and Jabber-based updating in particular), stability (updating my Avatar in Identi.ca does indeed work first time, every time, whereas it took me 10 tries to get it to work in Twitter), and ability to store my own name (This would make Twitter the first site that I have ever needed to call myself “Chris” as opposed to “Christopher”), that said, Twitter is ahead greatly in terms of the number of people on it, which makes sticking around there a necessary evil (boo for centralisation!).

End of Semester/Undergrad

And yes, it would be amiss to not note that last week was my last week of lectures as an undergrad student (presuming, of course, that all of my exams go sufficiently well), it was mostly uneventful, with the exception of having to hand in two major assignments, prepare and present a lightning talk, and run the session in which it was presented. All-in-all rather busy!

Cocomo: An experiment in metaprogramming in python

Friday saw the second edition of the UTAS Computing Society Lightning Talks, if you haven’t seen them already, I highly recommend that you check them out — this semester’s were at a very high standard indeed, and I wish I’d printed out more certificates for good talks :). My talk was a demonstration of using metaprogramming in Python, though that’s not what it seemed to be about.

An introduction

I went to the Apple University Consortium’s Cocoa Workshop at the University of New South Wales in February of this year, it was a heap of fun, and we learnt heaps whilst there. One of the key distinguising features of Cocoa is its use of verbose English method and attribute names, the idea being that each line of code should make a reasonable amount of sense when read aloud, hence:

NSString *str = [[NSString alloc] initWithString @"Hello World!"]

does indeed allocate memory to hold a string object, and initialises the newly-allocated memory with a string containing “Hello World!” (this code is highly redundant!). Supposedly such a naming scheme allows coders to write code that is easily maintainable by the original coder, and easily learnable by people who pick up the code for the first time.

On the other hand, my friends, collectively known as Maclab (named after the room at UTAS we inhabit) have developed a rather unique vocabularly, which in particular involves replacing as many words as possible with either ‘thrust’ or ‘fork’, so “Thrustingly thrust the forking forker” is not an uncommon utterance amongst my friends. If this is indeed their usual mode of conversation, then Cocoa’s way of identifying methods and attributes is not necessarily going to be a particularly intiuitive one. So, clearly, we need a version of cocoa that meets their needs.

The setup

So, conveniently, Apple provide a comprehensive version of the Cocoa API, thanks to the PyObjC project. We can therefore use the Python bindings for Cocoa facilitate our new version of Cocoa. Since Cocoa has a very consistent naming scheme, we can simply perform string replacement to translate from our maclab language to the standard cocoa language, using a routine somewhat like this:

 def translate(inp): ''' Translates an input string from key language to value language ''' for i in LANGUAGE: if i[0].islower(): inp = inp.replace(i, LANGUAGE[i]) inp = inp.replace(rtitle(i), rtitle(LANGUAGE[i])) else: inp = inp.replace(i, LANGUAGE[i]) return inp def rtitle(i): return i[0].upper() + i[1:] 

Here, LANGUAGE is a dictionary, with keys in the language code will be written in and values being the target language (in this case, Cocoa). There’s not all that much of a sophisticated nature going on in here. Now that we have a method by which we can translate our attribute accesses, we can get to the meat of the the code.

The implementation

To achieve the new API, we need to use a technique that I will call proxying. This involves the use of objects whose sole purpose is to intercept attribute accesses and calls to an underlying object. In this case, the point of intercepting the calls and accesses is to perform translation from our new objects to standard Cocoa objects. In Python we can do this by overriding the standard attribute access and call methods.

First up is __getattr__, the attribute accessor method — for this, we are passed a string; the name of the attribute that we’re looking for, which we translate, and then attempt to access upon the method on the underlying object (in this case, self.__u__). There is one slight hitch: in certain cases, we may not want to translate the attribute name. This is true, in particular, of the attribute that represents the underlying object. Hence we provide a REAL_ATTRS list, for which we use the default __getattr__ method for. This results in code that looks something like this:

 def __getattribute__(self,name): if name in REAL_ATTRS: return object.__getattribute__(self,name) else: new_objectname = "self.__u__.%s" % translate(name) new_object = eval(new_objectname) return CocomoProxy(new_object) 

Notice that we use eval to perform the lookup? It turns out that __getattr__ doesn’t work universally, whereas . notation does — so we use that for less failover.

Being able to call methods on the objects is important, but slightly more difficult — we want behaviour to be maintained, so we need to make sure that proper Cocoa objects are passed as arguments, rather than the Proxy objects that you may have originally dealt with. We can do this with Python’s argument unpacking — we build up a list of arguments, and unproxy them as necessary:

 def __call__(self,*a, **k): new_a = [i.__u__ if type(i) == CocomoProxy else i for i in a] new_k = dict( (translate(i), k[i].__u__ if type(k[i]) == CocomoProxy else k[i]) for i in k) return CocomoProxy(self.__u__(*new_a,**new_k)) 

We may also need to deal with iterators. This can be done using a standard generator function, thusly:

 def __iter__(self): for i in self.__u__: yield CocomoProxy(i) 

Finally, there may be legitimate reasons for extracting Cocoa objects, these include printing strings, so we provide an accessor method called no_really:

 def no_really(self): return self.__u__ 

And that’s the entire implementation! The final thing we need to do is provide a pre-proxied version of the base module for Cocoa. Let’s call it GypsyMagic.

The payoff

So now that we have a working bridge from Maclab English to Cocoa English, we can take this sample code that puts some stuff into an array, and then prints it:

 import AppKit hworld = AppKit.NSString.alloc().initWithString_("Hello, World!") arr = AppKit.NSMutableArray.alloc().init() arr.addObject_(hworld) arr.addObject_("Boop!") for i in arr: print i 

And write it in the far more palatable:

 from cocomo import GypsyMagic hworld = GypsyMagic.OGMouthWords.subsume().makeGogoWithMouthWords_("Hello, World!") arr = GypsyMagic.OGForkableTrinketHolder.subsume().makeGogo() arr.thrustinglyThrustForker_(hworld) arr.thrustinglyThrustForker_("Boop!") for i in arr: print i.no_really() 

If you’re interested in seeing how it all fits together, see Cocomo’s website.