Author: aucadmin

Alex Motyka, Univeristy of Sydney

When Apple announced the iPhone they turned everything we knew about the mobile user experience on it’s head. The iPhone and it’s radical gesture based touch screen user interface was considered 5 years ahead of it’s time and it lead to most radical shake up of smartphone industry ever. But did they get it all right? Many of the emerging standards in mobile user interface design and user experience/interaction are considered by some as almost self evident and natural but are they really? This talk will go through common and emerging UI/UX conventions and highlight what works and doesn’t work for the average user based on the findings of numerous usability studies performed by Neilson Norman Group.

The talk is intended for anyone interested in making usable native apps and/or mobile web apps that won’t confuse users. Participants will be taken through examples of apps and mobile web apps that work well and don’t work well. Areas covered will include button design and icons, gesture based navigation, task-flows, list design, forms and much more. The talk will have examples of web and iOS UI/UX design with a few Android examples thrown in for good measure.

This talk only requires a basic level of mobile and iOS programming knowledge.

Justin Marrington, University of Queensland

Track: Tools & Tech; Audience: Intermediate

This presentation intends to introduce – by example – journeyman and intermediate iOS developers to the techniques popular to the software industry at large for moving from decent code to great code. It’s a crash course in software design patterns, in unit and acceptance testing, in behaviour-driven development, in refactoring (and how and when to do it).

Each portion of the talk will be tightly focused about a practical example (rather than trying to describe the whole field), to introduce people to what’s possible, and point them to where to dig deeper. Where appropriate, we’ll introduce third-party tools (such as the Freddy framework for iOS-based BDD), and discuss alternatives.

Aneesha Bakharia, Queensland University of Technology

Electronics is fun and with the simple and versatile open hardware Arduino microcontroller, anybody can create impressive devices. This presentation will provide an overview of interfacing and controlling the Arduino from an iOS device.

Topics covered will include an introduction to the Arduino platform, using the Redpark serial cable to connect to external sensors, logging and plotting sensor measurements and controlling an Arduino with a iPad (multi-touch interface and accelerometer). A range of other connection options including XBee radio networks and MIDI will also be covered.

Matthew Robinson, Curtin University of Technology

Track: Tools & Tech; Audience: Intermediate

The Objective-C language is dynamic, many decisions are deferred from compile and link time to runtime. The dynamic nature of the language is implemented by the Objective-C runtime, which acts as a kind of operating system. Typically, you don’t need to interact with the runtime directly…

…but what can the runtime do for us if we choose to be atypical.

Categories are generally the first dynamic feature of the language that programmers new to Objective-C discover and this is where we will start. To understand how categories work we will look at message sending and method swizzling. From here we’ll be able to look at other features of the runtime.

In order to understand what the runtime is doing we will need the ability to inspect what it is doing internally, for this we will take a quick detour into DTrace profiling. We will also take a quick look at benchmarking to see if (and by how much) the dynamic nature of the language slows it down.

Messing around in the runtime has the potential to cause havoc, however, the runtime can be used to solve problems in novel and powerful ways. We will close by looking at some examples of using the runtime. Key Value Observing and Core Data are obvious examples from the Cocoa frameworks.

Tim Nugent, University of Tasmania

Track: Web & HTML5; Audience: Intermediate

Parse is a cloud-based backend service, designed to make a developers job a little bit easier by avoiding having to write boilercode. Rather than having to build a backend service and deal with serialisation, storage, transfer, security and the billion other issues associated with backends, Parse can take care of it letting us lazy developers focus on features.

This talk will begin with the basics of adding Parse into an iOS project and sending, storing and retrieving simple data.
The presentation will then cover what Parse is doing in the background and some of Parses different features and support including a brief look at the Javascript and REST APIs.

Finally the talk will discuss and demonstrate how to use some of Parses more advanced functionality, including user accounts, social network integration, geolocation handling and finally file transfer and mobile push.
The presentation will finish up with a basic comparison of Parse and iCloud and why you probably want to be using Parse over iCloud.

Peter Morton, University of Sydney

Track: Tools & Tech; Audience: Intermediate

iOS devices and robots are a great combination. Touch input, high resolution screens, a plethora of sensors and network connectivity means that an iPhone or an iPad is a perfect tool for robot control and data visualisation. Unfortunately, reliable communications is a difficult task which, in the context of mobile robotics, can lead to safety concerns.

This talk will look at three communications technologies from a robotics point of view. We’ll start with the basics of sockets and look at some of the lessons I learn whilst writing applications for the Australian Centre for Field Robotics’s mobile research platforms. The second part of the session will be about “Bonjour” (aka “zeroconf”), a technology for service advertisement and discovery, and will show how this makes finding and configuring network connections easy. We’ll go step by step through creating an application that finds and connects to services on a local network, and show how services can be created and advertised on Mac, Linux and Windows systems – including a demo with crowd involvement.

The final part of the session will be about Bluetooth Low Energy, an exciting new technology built into the latest Macs and iDevices that allows them to talk wirelessly to peripherals using tiny amounts of energy. I’ll go over the basic concepts of Bluetooth LE, discuss how these are implemented in the CoreBluetooth api and then look at how this enables developers to create their own peripheral devices. We’ll finish up with some demos involving a mac, Bluetooth LE USB dongles and a Rapsberry Pi.

You can find code that accompanies the talk on GitHub:

• https://github.com/petermoz/devworld_sockets
• https://github.com/petermoz/devworld_bonjour
• https://github.com/petermoz/devworld_bluetooth

Paul Beaumont, Royal Melbourne Institute of Technology

Track: iOS; Audience: Beginner

At RMIT University built our mobile student application in HTML5 CSS3 but we wrapped it in an iOS application. This talk will look at some of the advantages and disadvantages of the approach. This talk will be of interest to anyone who trying to decide on a strategy around Native iOS verses HTML5, or who has already embarked on building a HTML5 application.

Outline:

Our Approach

• Mobile Strategy – target of 95% of students
• Agile in a non agile environment
• Design
• User engagement

Our Architecture

• Data layer
• Service layer – REST
• Web UI – JQuery Mobile
• iOS

Features of the Application:
Without going into a full feature description, we will call out some of the key features of the application, focusing on the integration of location – we incorporated “way finding” at a low level.

• Announcements
• Timetables
• Maps Integration
• Security

Frameworks:

• Investigated a number
• Used JQuery mobile
• Looked at iOS frameworks such as Titanium
• Went native for the wrapper

Native features:

• Very limited
• Connectivity testing
• Splash screen
• Place holder for the future – ie Push notification

What worked well:

• Re-use
• Skills
• Maintenance
• Security

What we would do differently:

• Design constantly
• Handling external links
• Look and feel (you can’t quite get it right)
• More localization of data
• Perhaps a fully native application!

Tim Raphael, Murdoch University

Track: Web & HTML5; Audience: Intermediate

As everything seems to be floating up to the cloud, the pairing of web services with mobile applications is becoming a popular trend. In this presentation you will learn how to make your own RESTful web service and how to integrate it into your app using Cocoa and other third party libraries. I will also be demonstrating RESTful web service concepts and application architectures that have worked for me in building my own system.

Matthew Heinsen Egan, University of Western Australia

Track: Tools & Tech; Audience: Intermediate

Apple and its primary development environment, XCode, have recently abandoned the long-favoured GCC, replacing it with Clang and LLVM. For most Apple developers, this change has been seamless and invisible, but importantly it affords great opportunities for the teaching of programming languages in universities. Not only have XCode and related tools been significantly improved by this switch, but the design of Clang and LLVM facilitate the development of new teaching tools, not previously possible with GCC.

This presentation will introduce our development of new novice-focused debugging tools for the C programming language on Mac OS X. C remains important for students: it is used to teach operating systems and networking concepts, and is the foundation of other important, widely-used languages (such as Objective C). Novice-focused debugging tools can assist users by detecting and explaining runtime errors, providing explanatory information, automatically visualizing memory, and by using simple, intuitive interfaces.

We are developing novice-focused debugging tools, with high-quality maintainable support for the C language, by leveraging the LLVM and Clang libraries. Previous teaching tools used custom-built parsers, interpreters, and instrumentation methods, which were exceedingly complex and have proven to be unsustainable. Furthermore, their support of the language is often fragile or incomplete. This presentation discusses our use of LLVM for compile-time instrumentation, and our use of Clang for parsing and examining C source code. We will explain our use of advanced techniques, such as automatic detection of runtime errors and reversible debugging, and how they assist our teaching using OS X.