The June issue (paywalled, also looks awful online for some reason) of STA News (the NZSTA periodical) included an article “Collaborative Copyright”, regarding the ownership of intellectual property created by teachers and other school employees. This topic has been getting a lot of attention (on Twitter, anyway) for a while now.

To be clear, I’m a big fan of Creative Commons (and have released things I’ve created under CC licenses for a decade now), of collaboration, and of giving education employees control over intellectual property that they create. In 2012, not long after I joined the Board at Ahuroa School, I made sure that the board considered this issue, and suggested Creative Commons licenses as one possible way forward (the board decided to go with another option I suggested, of gifting the property to the staff in exchange for a permanent license to use it).

However, there are parts of the article that bug me. The worst part is in “setting the scene”:

Under New Zealand law, like many other countries, anything that is created by an employee in the course of their work for their employer is regarded as belonging to the employer. This makes absolute sense in the context where, for example, the employee is producing biscuits or cereal at a factory – the factory and its output logically belong to the person or company.

It all makes rather less sense though when the work being done is “knowledge work” that depends on the employee’s own personal skills and experience to create something unique or to provide professional services – like an inventor, a painter, a professional sportsperson, a surgeon or lawyer or teacher.

I am one of these “knowledge workers”, and employ others, providing professional services (software development, design, management, research). Just because I’m not producing a biscuit that you can eat, doesn’t mean that my employer should be required to give me ownership of what they pay me to make. The same applies to these other jobs – if a sportsperson develops some sort of innovative gameplay, then the employer is just as entitled to the product of their paid work as of the surgeon that develops a new technique or the software that I write.

It’s great to share – e.g. I contribute work as open-source projects when I can, and encourage people that pay me to produce work to do the same. However, that choice belongs to the person that is paying for the work to be done, not the person who does the work. The biscuit isn’t owned by the employer just because they provided the raw ingredients, but because they provided (by paying for it) the labour it took to make it. If you take away all the ingredients except for the labour, that doesn’t mean that the ownership should suddenly transfer.

I realise that there are people who disagree with this, and have fairly extreme views about all knowledge being free. However, I don’t believe that NZSTA are fairly representing boards by espousing that view.

There are much better reasons for intellectual property that is created by school employees to be ‘naturally’ something that should be shared. In particular:

Although the board is the employer, the vast majority of employees are funded via the government (a few will be funded via some other source of income that a board has, but I’ll ignore that for now). The government’s money comes from (approximately) the people of the country, and so it’s reasonable to expect that anything that the government produces should be available at reasonable cost to the people of the country. For example, this is the same argument that says that government-funded research findings should be freely available. I absolutely agree with this, and it is a convincing argument for making teacher output freely available.

Most of what these employees are making is incidental to their primary work, educating our children. I am specifically employed to create intellectual property; teachers are not. A painter is specifically employed to create intellectual property – a sportsperson possibly not. I don’t think that being incidental is a compelling argument for sharing on its own, but it adds weight to an argument.

The majority of the intellectual property that these employees are making is of low or no monetary value (which is not to say that it is worthless). Those blog posts, tweets, and Facebook posts that teachers are writing are most likely not going to be a source of income for the school. The worksheets, assignment outlines, and plot summaries are fairly unlikely to generate any income either. If you can share something at no cost to yourself, then that’s also a compelling argument to do it.

If you are going to try and convince someone to make a positive change, then it works much better if you start from a balanced, accurate, position.

Note that these are my views, not necessarily those of Ahuroa School. IANAL.

Kiwi PyCon 2013 was held last weekend at AUT in Auckland. This was the first time I’ve been able to attend; although I’ve planned to in previous years, the timing never worked out (even this year was very tight).

I missed Michael’s keynote, unfortunately, and also the first session, because it’s also the end of the winter sports season, and so I had to attend prizegiving that morning. If the conference had been somewhere else, I probably couldn’t have attended at all, but since it was only ~65km from where I live, I could still attend most of the two days.

The first talk I attended was Integrating Javascript with Python Web Frameworks. This is an interesting topic, and was well presented, but seemed more novice than intermediate to me. Unfortunately, most of my interest in this topic is more on the side of light Javascript integration (i.e. where the bulk of the work is still done on the Python side), and the talk focused on the other area. However, that wasn’t a flaw in the talk, just a limit in what I got out of it (it seems likely that by the time that I ever do something that’s Javascript-heavy, if I ever do, everything will have changed considerably by then).

Next up was Testing and OpenStack. I’m only vaguely familiar with OpenStack, and the abstract is very poor, but I don’t like changing tracks mid-session, and testing is of interest, so this was the talk to attend. Again the presentation was fine, but the talk seemed more novice and less intermediate (some familiarity with OpenStack was assumed, but I don’t consider that means that the talk itself was at an intermediate level). I didn’t really take much away from this.

The final talk in the session was Python and Creative Data Analysis. This was a novice talk, and for someone at novice level, probably well worth attending (it was presented quite well). For someone not a novice, even someone with nearly no matplotlib experience (like me), there wasn’t much to be gained.

For the final session of the day, I started with Dissecting Memory Mysteries of Python. I had a lot of hope for this presentation, because this is an area of interest for me, and practical advice would be really useful for work that I do. It was labelled as an intermediate talk, and I would say that was accurate (but I was probably hoping for more of an experienced level talk). The presentation was ok, but suffered from having two speakers, one of whom spoke too quietly. The talk did cover some of how memory management works in Python, but concentrated too much on reference-cycles for my taste (which I find in practice is never the problem when short on memory), and their practical suggestions for improving memory usage weren’t really that good. For someone with no previous understanding of how Python manages memory, this would probably have been a good talk.

The final talk of the day, Using Cython for distributed-multiprocess steganographic md5sum-collision generation. For… reasons, was the best of the conference. The speaker was excellent – far superior to most of those at the conference, and the talk was entertaining and somewhat informative (mostly entertaining, but that’s exactly what it claimed to be, and those are often the best talks at a conference: pure information is better found elsewhere). The only negative was that the abstract was pretty poor – it doesn’t really reflect what the talk was about at all. If the conference had 5 talks of this quality, I would have no hesitation towards attending again.

The second (or third, if you count the tutorials) day was opened with a keynote by Jessica McKellar. Jessica is a very good speaker, and the topic was suitable for a keynote, especially from someone with her background. Essentially, she was advocating increasing involvement with and usage of Python, and going over what she saw as the key barriers to entry at the moment, and therefore what should be targeted in order to help Python remain popular (her brief explanation of why popular is important was well done). Although I certainly agree with her central tenet (everyone needs to do a couple of small things and that’s enough to make a significant difference, and that difference is important), I don’t agree with all of the examples she gave. Her four points were Windows, games, mobile, and science (the latter being an example of something that is working well; i.e. where we can copy ideas from and remain strong).

I started with Python on Windows, although I almost never use it any more. There are some difficulties, although I think that if you’re the sort of person for whom programming is a good match, you can work through the issues without much difficulty – the challenge would be more with ‘casual’ programmers – e.g. a scientist that could use Python to do something, but isn’t really a developer. Most of the challenges here I think can be addressed by documentation – e.g. the Python Tools for Visual Studio are excellent, fairly simple to use, and familiar to a lot of Windows developers. All that they need is more people pointed towards them. I don’t know enough about the casual programmer to know how they get started, but it seems like better documentation would help them too. However, the core of my disagreement here is that I’m convinced that Windows use is imploding – this is going to happen more rapidly than people realise, and so putting a lot of effort in here is not a good use of resources. It would be far better to target mobile instead.

Although Python isn’t necessarily the first choice one would make for games, I think the examples that Jessica gave were really just a re-hash of the Windows issues, and those will also just go away as fewer games are developed on/for Windows, in favour of mobile devices and possibly consoles. I would argue here that again the resources would be better spent on making sure that developing games on the web, iOS, and Android is as straightforward and well-supported as possible.

Her last two points, mobile, and science, I do generally agree with, although I think she undersold the mobile issue. For example, there are many people that will only be using a mobile device – they need to be able to actually develop on iOS or Android (or maybe Chrome OS), not just build for it. There are some tools for this – some that are really pretty good, but more would be better.

The first proper talk of the day was Exploring Science on Twitter with IPython Notebook and Python Pandas. Again, this was labelled as intermediate, but really was novice. It was an ok introduction to IPython Notebook in particular, but not a lot more than that. For a novice, or someone that had never heard of IPython or Pandas, probably valuable. For others, not so much.

The second talk of the session was From nothing to daily use: How Python changed my work life. This was correctly labelled as novice, but was by another excellent speaker. There wasn’t much to take away in terms of Python development, but it was a great insight into non-programmers (sort-of) coming into Python, and how Python is in use at a central New Zealand organisation. Again, if there were five talks of this quality, then PyCon NZ would be an easy recommendation.

The final talk of the session was Advanced methods for creating decorators. This was correctly labelled as experienced (one of only two at the conference), and was exactly what it claimed to be. The speaker read the presentation, which is never great (I’m not sure what I got from it that I wouldn’t get from reading an essay), but otherwise it was informative and well done. More talks like this, especially if they were better presented, would be excellent.

After lunch I attended Publishing Theology with Python, again labelled as intermediate but actually novice. For a novice talk, it was fine. I was hoping for more practicalities, and more focus on getting Word documents to ReST (when actually that step is done by a raw copy and paste and manual markup), but it was moderately interesting.

Prior to afternoon tea were the lightning talks (around 12, I think). These were generally very low quality – there were a couple that were worth listening to, but many that I would rather have skipped, and some where the speaker was both not good at speaking, and didn’t really appear to have anything to say. Too many people used it as a “share what you are doing” opportunity, rather than something that would be of interest to the group.

The final session of the day started with Computational Advertising, Billions of records, and AWS – Lessons Learned. This was listed as experienced, but was really intermediate (at best). A poor abstract (just throwing together a lot of words, really), but an ok talk. Either more practicalities (exactly how were things done), or being much more general would have improved this, rather than the middle ground that was taken.

The last session of the conference was the third-best: Testing for Graceful Failure with Vaurien and Marteau (actually Loads). This was accurately intermediate (although on the novice side rather than the experienced side), and very well presented. The two tools sound interesting, and definitely something that I’ll be checking out (these are the only two tools that I learned about at the conference that sound worth investigating). It would be great to see more talks like this.

There’s not much to say about the rest of the conference – it was fairly typical (venue, food, etc – although the swag-bag was very light). There were a lot of giveaways (t-shirts, books, licenses, etc) that took a lot of time and were a bit odd. I don’t really understand why people would applaud someone who was just randomly selected to get some free stuff, or why the giveaways needed to be drawn out so much. In general the organisers did a good job, though – it’s not really their fault that the quality of talks (and speakers) wasn’t as high as it could be (unless they turned down the good talks, which is unlikely). It’s possible that I missed some great talks – I’ll be watching the videos once they are available (most of them, if not all).

Two issues that should be addressed for next year are the “audience level”. Of the talks I saw, there was only one that was actually experienced, four that were actually intermediate, and six that were actually novice. Many of the novice talks (and one of the intermediates) claimed to be higher. The first problem is that the level need to be accurate, so that people can go into a talk with a realistic expectation of what’s required. The second problem is that this skews far too far towards novices – there needs to be more experienced talks in particular, and more truly intermediate ones as well.

Overall, I wasn’t particularly impressed. Since the conference was close to home, it only cost me around $400 (travel, registration, food), which is very cheap as far as conferences go, but could instead pay for a new iPad Mini (which I’d use for much more than a weekend), or several books, or licenses, or various other things where I think I would get better value. If I was looking for work (or workers), or for collaborators on an open-source project, then I can absolutely see value. However, I’m not doing any of those right now. If the conference had more experienced-level talks, more inspiring talks, and more great speakers, then I would absolutely attend again. If I was a novice, or low-level ‘intermediate’, then I would certainly see value. The venue for 2014 wasn’t announced (Dunedin was two years ago, and they tend to alternate, so I would guess that Christchurch and Wellington are the two most likely, although Hamilton might be a contender), but as things are I’m not really sold on attending again, unless the speaker line-up looks particularly good, or something else changes (e.g. if I am looking for workers).

An option that I would be interested in, but I doubt will be done, is a “green” option for attending. I would pay a discounted registration (90%?) to get access to live streaming video of the presentations and a posted t-shirt (or even the whole conference bag). I can still interact with other attendees in real time (via Twitter, ADN, etc – questions can also be handled this way), if not to quite the same level, get much the same out of the conference, and save a lot of the cost (e.g. even this year with it so close to where I live, I would still save 75% of the overall cost), and be much more environmentally friendly (i.e. reducing wasteful travel).

Codea (formally called Codify) is an $11 iOS application in which not only can you develop applications, you can run them (you can’t run them outside of the app – i.e. this isn’t a way to develop iOS applications).

The application is very pretty – and that counts, this is iOS! At launch, you’re presented with a set of example projects, and you can create your own (I don’t think touch-and-hold is a great way to get the contextual menu for delete/duplicate/copy into new project, but it works well enough).

Inside of a project, there are two views: the code editor and the execution window. The editor is good – it’s not as good as Textastic (and there’s no configuration possible – not even changing font size via pinch & zoom), but it’s perfectly usable (the worst part are the tabs at the top where you can switch between files, where the tabs are bizarrely small). There are elements of the editor that are superb: if the editor can tell that the function arguments are a colour, then you get a colour wheel, if the argument is a sprite, then you get a sprite picker, and so on. That’s the way to make coding on an iPad faster and more enjoyable. The keyboard, like Prompt and Textastic, has an additional top row with keys you’re likely to need (paired quotation marks and brackets, +=, and so on – it’s interestingly a very different set of keys to Textastic (both have their advantages). Also available via this extra keyboard row is a very nicely formatted set of help documents that explain the methods that are available and how to use the app in general.

Applications are developed in Lua – this isn’t a language I’ve done a lot in, but I’ve seen enough and it’s similar enough to other languages that it’s easy to get familiar with it. I sincerely hope that the developer plans to offer additional languages (Python!) in the future (perhaps as in-app purchases?). Most importantly, there are methods available that expose the iOS interface to the code (especially touch information and drawing routines). These are somewhat limited compared to writing an iOS Objective C application in Xcode on a Mac, but perfectly usable in this context.

Once the application is complete, you can switch to an execution window. Two thirds of the screen are the application’s display, with a sixth for textual output (e.g. debugging) and a sixth for parameters (e.g. sliders that you can use to pass values to the application – these are extremely easy to use in the code). Unfortunately, given Apple’s restrictions on apps, this is all that you can do with an application at present.

The app is well made and does what it aims to do very well. There’s clearly room for expansion (minor interface tweaks, more languages, more access to iOS features) as well. The remaining question is whether there is any practical use to the app, given that you’re restricted to running your applications within the Codea app itself.

(It’s possible that this restriction will be lifted or weakened in the future – with Apple it’s difficult to tell. It does seem likely that there could be a version of the app that allowed you to export (as a collection of text files) and import code, just as an application like Textastic can – or even some sort of seamless sharing via Dropbox or iCloud. This would make it easy to share applications, but you’d still need to run them in Codea itself, unless they were pure Lua and didn’t use iOS at all. However, it seems feasible that someone could then write an emulator/interpreter for Codea apps for OS X (replacing touch with the mouse), so you could run your apps externally if you liked. It seems very unlikely that you’ll ever be able to turn them into full-fledged iOS applications).

The app demos very well – it shows a glimpse into the future where not all development is done on traditional desktop/laptop systems. However, I can’t see how it can be of any practical use – except for education.

For education, this seems like an extremely valuable application. In an educational context, it doesn’t matter if the app can run standalone or not (it would be nice if you could easily share it with someone else, like a teacher). The interface is approachable, and the language friendly, and there’s potential for creating very impressive apps. I would love to teach a short course where the students did all their development in Codea (perhaps on a beach away from a typical “lab” environment…), assuming that the students all had iPads already (and we have an AppleTV and large TV to demo things to each other). I hope that someone does do this (and writes it up somewhere where we can read about it!).

This application is amazing. Even if you have no interest in programming, you should buy it to support the developer. If you do have an interest, you should have bought it already.

Textastic is a programmers editor for iOS. It’s not perfect, but it’s very close to the app that I was waiting for ever since the first iPad was released.

Even before I had an iPad, I’d mostly stopped using my laptop. The only time I did use it was when travelling overnight (I’d take it if I had to work while away, or in case there was an emergency and I had to work on something). I don’t need a full computer for this – typing on a software keyboard on a 9.7 inch screen is perfectly adequate for emergency work, and when combined with a bluetooth keyboard (which is small enough to easily pack, and I already own) and a monitor (now a TV via AirPort mirroring) it’s quite useable as a work-while-travelling device.

The only missing component was the software: for a very long time there was nothing available. There are oodles of word processing applications, note takes, and there are even a few HTML editors – but nothing designed for real programming work. I’m not sure why this is, but I suspect that most professional programmers already have something along the lines of a small MacBook Pro or Air and find it convenient to travel with that, so wouldn’t use an iPad, even in these situations. The best available was, unfortunately, using SSH (this was before Prompt, too) and doing the word in a command line on a server somewhere.

At $14, Textastic is expensive for an iOS app, but cheap for a programmers tool (it’s definitely worth the price). This is a text editor, not an IDE, so you don’t get a debugger or interactive prompt or anything like that – it would be difficult to do that anyway given Apple’s restrictions, and I prefer a dedicated programmers text editor to an IDE anyway. (You can easily switch to other apps that together provide most of what an IDE does).

It’s a good editor – it does syntax highlighting for many languages (including Python and everything else I’m interested in), shows line numbers, and you can switch the file’s encoding and line ending choice. You can quickly jump to “symbols” (e.g. method), although I generally just scroll since I know where I’m going. There’s a decent find (and replace), and you can choose from DejaVu Sans Mono, Courier New, Luxi Mono, Monofur or Inconsolata for the font. There are a variety of colour themes, there’s control over tab settings (including soft tabs) and word-wrap. Although you can set the font size, you can also just pinch & zoom to get the size that you’re after, which is far superior to manually picking a size.

Generally the app does what it should: it gets out of the way and lets you get on with writing/editing the code. There’s an additional top row in the keyboard that offers symbols that you’re likely to need (this oddly scrolls horizontally to fit everything in) so that you don’t have to toggle between keyboards often (except for numbers) if you’re not using an external keyboard.

Where the app falls down for me is where iOS in general performs badly: moving data between applications. You can share files to the app (e.g. from Dropbox), and there are actually many ways of getting files in and out (via WebDAV, iTunes, creating local files), but you’re left with the same issue that lots of iOS apps have: you end up with duplicates. To its credit, the app tries to address this (e.g. it can know that a file you’re editing belongs in a particular Dropbox location and sync the changes back), but at the end of the day it’s clearly a hack. The app is still useable, but this does mean that I more often read code in it than write it (it’s far better for reading code than the Dropbox app is).

It seems obvious to me how to fix this problem (I don’t understand why it isn’t already the case). Surely nearly every programmer that would use this app has their code stored in some sort of repository (CVS, SVN, Git, Mercurial, Bazaar, etc). The repository is the file system. The app has a working copy checked out, and you can commit changes back to the repository. The app doesn’t need to support every action that the VCS/DVCS offers – really just (in SVN terms) add/remove/update/checkout (and perhaps propset) – if you need to do something else, then you use a dedicated SVN/Git/etc app). This completely solves the issue of multiple copies of files, because that’s exactly what these tools are designed to handle.

Unfortunately, the app would need to support at least SVN, Git, Mercurial, and Bazaar since there’s a lot of diversity at the moment. However, it seems likely that there are libraries that can be used (even in iOS) that would handle a lot of the grunt work. If the app let me check out a SVN working copy, make changes, and then commit them back, it would be absolutely perfect (I’d pay ten times the price if the app supported this).

If you need a programmers text editor on iOS, then I highly recommend Textastic.

Panic’s Prompt is the SSH iOS application that I (and I’m sure many others) were waiting for from the release of the first iPad. My only complaint is that it took over a year (a year of using considerably inferior alternatives) before the app was finally available.

SSH isn’t pretty, but somehow Prompt is. Although there’s a lot of space required for the keyboard, connections, and settings, Prompt somehow makes the remote display quite large enough to be readable (and if you use an external keyboard, then it’s perfectly sized, and you get the control keys and arrow keys working as you’d expect). Connection management is very simple, and all the settings you’d expect (initial command, prompt string, etc) are available.

The keyboard includes an additional top row that has the keys that you need to use most frequently in SSH (escape, control, tab, /, -, |, @, arrow keys) and are missing from the standard iOS keyboard. It even autocompletes using the shell history, saving typing long paths and commands repeatedly.

There’s very little I can say about the app other than if you will ever need/want to SSH from your iPad, then this is, without any doubt, the application to have. It’s $11, but worth easily five times that much; I’d grumble and probably try and convince work to contribute to it, but I’d pay $100 for it. If you don’t know what SSH is, then this is not the app for you.

(Before Prompt, I used iSSH which also does VNC – I use VNC a lot less frequently, but still need it occasionally, so now I need to figure out which is the best VNC app, which are unfortunately all fairly pricey. If you have suggestions, let me know!)

Cards is one of the lesser quality Apple iOS apps (think MobileMe Gallery rather than Keynote). The premise is simple: you create a greeting card on your iOS device (just like you would in iPhoto) and through in-app purchasing you pay for it to be printed and sent (anywhere in the world) – unlike in iPhoto where you’d have to order many and they’d be sent to you to then send on.

Aspects of the app are good – the templates are very customisable and generally nice, and it’s a pretty simple process to create a card. The pricing ($6.50 including postage) is extremely reasonable considering the cost of a decent (not customised) card elsewhere.

However, there are considerable flaws: the purchasing is odd – it doesn’t use the standard in-app purchasing system (I can’t understand why not), so you’re prompted for more information than simply your App Store password; the App is bizarrely iPhone/iPod resolution only (nearly the same interface would work perfectly well on an iPad, where you’ve got access to all your high-quality photos via Photo Stream anyway); and the cards take forever to arrive.

The latter is the most significant flaw, of course. In a few cases (e.g. “thank you” cards) it doesn’t matter how long the card takes to arrive; in most cases (birthdays, anniversaries, Christmas, …) timing is actually very important. We sent a card while visiting the Auckland Museum at the end of the school holidays, and it took over a week to arrive; one has apparently been sent to us (around the same time) and has yet to arrive. The “shipping notification” email arrives days before the card does, indicating that the problem isn’t in the printing, but in the delivery (presumably they are being printed in Australia and there’s some sort of international shipping delay causing issues).

It’s likely that this is a problem specific to New Zealand (and perhaps isolated other countries). Unfortunately, that does mean that it’s less likely that it’ll be quickly fixed. We’ll probably try this again in a couple of weeks, and see if the speed has improved – if not, then the app is only useable in rare circumstances, which is unfortunate, because we’d likely otherwise use it quite frequently.

The SkyTV iOS app is free, and I rarely use it, but on occasion is is very handy. The application is mostly a TV Guide – since SkyTV refuses to let anyone else have their listings, but they do have all the free-to-air channels, it’s clearly the best guide. However, I don’t really have much use for a guide, because I’m never looking for something to watch (everything I’m interested in is scheduled to record).

Where the app is occasionally useful is that it can be connected to your MySKY box, and you can remotely schedule a program to be recorded. This is essential for those times when you’re away from home and remember that a new program is starting in a few hours and you forgot to schedule it. The scheduling is limited (e.g. you can’t set up a series link), but it’s good enough for these situations.

As you’d expect from SkyTV, the process of setting this up is incredibly painful. You need to enter your SkyTV account details and the unique ID of the smart card in the MySKY box, and although this should be a smooth process, it never works first time – and then, without anything being done at all, will ‘magically’ start working at some later date (I’m guessing that the linking process takes time, and the app fails to tell the user this, leading them to believe they did something wrong).

Once it is finally set up, though, it’s very simple to use – just find the program you’re interested in recording and a few taps later it’s scheduled. Test it at home first, of course! (But not right away, because, as above, it doesn’t appear to work until a few hours have passed since the initial setup).

If you’ve got MySKY and an iOS device, then this is absolutely an app that you should have installed (it is free, after all!). If you don’t have MySKY, but you do want to use a TV Guide on iOS, then this is the more comprehensive one for New Zealand listings, so (again given that it’s free), it’s worth having.

Note that the app doesn’t offer any sort of iSKY (on demand video) access. It would be extremely nice if that was added in the future, but I’m skeptical that it will be.