Today’s start was a little late for me – not through the action (or inaction) of any beer, but of the pleasures of the M1 and the many accidents along the way. So much for being nearby …

In any case, Michael Jurewitz (@Jury) gave the opening presentation on day 2 about how to maximise profits on the app stores. Having been a developer tools evangelist at Apple, and now at Black Pixel, he certainly knows his stuff, and this presentation was no exception.

The first piece of advice is “Know your market”. You may think you have the best idea for an application, but if no-one is going to use it (or worse, it’s in a section of the app store with a low average price or heavy competition) then you aren’t necessarily going to make a lot of money on it. Some stats from the talk; the average selling price for the Mac app store categories were:

• Social: $8
• Developer: $30
• Business: $48

Having a known market place allows you to target your price point effectively. Being able to calculate how much the sales change over time, especially with different price points, allows you to calculate what your expected revenue would be if your app was sold at different points. To find out, double your app stores and then calculate the change in price vs change in qty sold; from that you should be able to calculate the average price point to maximise your profits. Or, as @MrRooni posted on twitter “Everyone at #nsconf is currently logging into iTunes Connect and doubling their app prices.”

Talking to Hardware

Alasdair Alan (@aallan) gave a really interesting talk on how to use iOS to talk to hardware devices. Although there are official Made For iOS programmes, the hobby market is not well suited to that market. There are a number of ways that you can talk between an iOS device and an external system that don’t include MFI:

• Using the camera kit and a USB-to-Midi adapter, and program with CoreMidi (see https://github.com/bjepson/iPad-MIDI-Simple-Demo for more information)
• Use an IR sensor and the screen, along with a capacitance sensor taped to the screen (used very effectively by Misfit Wearables)
• Use PeerTalk to have a network connection (see http://www.dailyack.com/2012/08/peertalk-and-beaglebone.html and http://www.dailyack.com/2012/08/blinking-beaglebones-heartbeat-led-from.html)
• WiFi using a client and server – though problematic for discovery/setup
• Accoustic couplers (e.g Square, also see the HiJack from SparkFun and SeedStudio)
• Redpark RS232 cable – http://redpark.com/c2db9.html
• Bluetooth low energy (BT4)
• XBee for iOS – see wikipedia or Digi for more

The talk concluded with a live demo of flashing an LED – which, as Alasdair said “is half-way to anything” programmed on an Arduino board and with the http://arduino.cc/en/Guide/MacOSX setup instructions.

TouchDB

The next blitz talk by Matias Piipari (@mz2) gave an introduction to TouchDB for iOS and how it can be used to store arbitrary JSON documents on an iOS device.

TouchDB provides a CouchDB-like model, with documents storing arbitrary JSON schema and available with a unique ID. As well as a mechanism to load and save the documents as NSStrings, there is also a Model concept which allows you to define a dynamically implemented model provider that maps to fields in the underlying document, with cross-refrences between objects being automatically loaded:

// ShoppingItem.h
#import <CouchCocoa/CouchCocoa.h>

@interface ShoppingItem : CouchModel
@property bool check;
@property (copy) NSString* text;
@property (retain) NSDate* created_at;
@end

// ShoppingItem.m
#import "ShoppingItem.h"

@implementation ShoppingItem
@dynamic check, text, created_at;
@end

The fact that all of this is done automatically means that the model is both really easy to implement and also easy to evolve should the schema of the data changes.

For more information, see https://speakerdeck.com/snej/introduction-to-touchdb.

Subscription Pricing

Manton Reece (@manton) started with a premise that software sales of packaged software is dead, and is being replaced with subscription model pricing. He cited Adobe’s recent Creative Cloud which offers a monthly pricing model for access to Adobe’s software, and Microsoft’s Office 365^*

The advantages of subscription pricing is that everyone is on the latest version (since there’s no compelling reason to stay on an older version) and that customers are happy (if they’re not, they unsubscribe). For ‘living’ applications where updates are regularly being provided or a valued service is being hosted, an on-going fee is appropriate and can let the user feel that they are giving something back.

The change is instead of charging to rpovide the software (e.g. a paid download on the app store) you charge for on-going access to a service (like App.net or DropBox).

In order to perform subscription models (other than the app store) Manton highlighted a few companies providing subscription services including both unpopular suggestions and other ones, such as Stripe.

^*: May not work on February 29th

Finder Injection

Steve Flack talked about how to perform injection into Finder, using a combination of class-dump to generate method signatures suitable for probing the internals of Finder, and Hopper to provide decompilation.

There was a lot of detail into the internals of Finder, but the technique relied on the fact that mach_inject and mach_override to replace the implementation of a pre-existing method using a technique called method swizzling.

Fluffy Talks

There were also a number of non-developer talks. One of the fluffy ones was @fluffyemily aka Emily Top, who presented at last year’s NSConf and reported that the start-up, TinyEars, didn’t succeed and some learning points for last time. A brave talk (possibly not best to have a learning talk right at the end of a day) and useful information for those considering whether a start-up is a sure thing or not.

Nathan Eror (@eror) gave a ‘step away from the keyboard’ talk on taking care of you as a person and doing/eating the right things, rather than just focussing on beer-filled and pizza-fueled coding.

Pieter Omvlee gave a retrospective on what happened when Sketch was developed; always useful to have a retrospective, and Rob Ryne gave a talk on ‘Being naïve’ by developing the simplest thing that would work (admitedly, with quite a cool UIBezierPath demo) but mostly common sense.

Wrap-up

Sadly, I won’t be at the final NSConf day, as I have other commitments at QCon London, so today is my last day (and thus, my final write-up).

Traffic this year on #nsconf was down on last year – mostly because the WiFi connectivity failed (caused by the fact there were more than 300 attendees, most of which had 2 or more WiFi devices). Another factor is that many iOS developers are now on App.net (though not exclusively) and GlassBoard as a private invite-only messaging board for NS Conference attendees. Focus was thus split over several places where perhaps before there had been one.

Finally, the location. It’s a brave conference that decides to up and move; the shift from the middle of nowhere to the middle of Leicster was a brave decision. What the move did was double the size of the attendees that could come; from roughly 125 last year to over 300 this year. Plus, since most people come by public transport (or come and stay) the central location in the country and near public transport suits many people well.

Sadly it didn’t work too well for me; I got stuck in a traffic jam on the M1 on the second day for an hour or so and as a result I missed the first part of Jury’s talk.

But the conclusion is; more people were involved in this year’s NSConf, and it’s certainly bigger than it’s ever been before. That in turn means a stronger future for NSConf and its attendees. Hopefully I’ll catch you at the next one.