“Hello, Robot” – Talking to hardware with TCP, Bonjour and Bluetooth LE

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:

Building a “Wrapper” Application in iOS and HTML5 CSS3

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.


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


  • 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!

Web Services and Cocoa

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.

Developing novice-focused debugging tools for C using LLVM and Clang on OS X

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.

Erndersterndin Web APIs in Objective C

Nic Wittison, University of Tasmania

Track: Web & HTML5; Audience: Intermediate

Did you ever wonder how your friend’s status update makes its way from the depths of the internet in to the palm of your hand?

This talk covers the basics of asynchronous Web APIs and how you can make sense of the networking framework provided in Cocoa to create up to date content rich iOS/OSX applications. It will show you how to use Web APIs to easily send and receive data from a web service and how to handle and parse that data for use in your own applications.

Integrating the [video] element with HTML5

Thomas Verbeek, University of Otago

Track: Web & HTML5; Audience: Intermediate

HTML5 introduced the video element to provide a standard way for playing videos on the web without plugins. It’s popularity is rapidly increasing with increased support and capabilities across browsers. Aside from being a replacement for Flash, the video element can also be used for synchronized media, CSS filters and more.

This presentation will be a beginners guide through the video element in HTML5. It will cover the basics of the element (what it is, how it is supported); syntax for defining and interacting with the video element (HTML syntax, attributes, integration with other elements); some simple techniques (controls, poster, CSS filters); more advanced manipulations (media controllers for synchronized playback, fullscreen display); and the politics of browser support. Prior knowledge of general HTML and Javascript is expected.

Hot Knife Through Butter: How to achieve smooth scrolling in UITableView

Jimmy Ti, Queensland University of Technology

Track: iOS; Audience: Intermediate

The iPhone was revolutionary for its use of direct manipulation – its great user experience comes from the feeling that you’re really holding the content in your hand and manipulating it directly with your fingertips. While many mobile platforms have touch, it is the realistic physics and fluid animation of the iPhone that sets it apart from its competitors.

UITableView is the corner stone of many iOS apps, and how well scrolling performs in UITableView will, in many cases, make or break the experience of an iOS app. In order to provide the best experience to the users, we should always treat 60 frames-per-second animation as a priority.

This presentation will discuss about common issues that causes jerky scrolling animation in UITableView and what are the strategies we can apply to achieve buttery-smooth scrolling in UITableView.

OpenGL ES and GLKit: Valuable Assets for Hardware-Accelerated Visuals

Mustafa Youldash, La Trobe University

Track: iOS; Audience: Intermediate

The Open Graphics Library (OpenGL) is the most widely adopted 2D and 3D graphics Application Programming Interfere (API) in the industry. It is an open-standard that enables developers to create high-performance, visually compelling graphics apps for digital content creation, scientific exploration, computer animation and mathematical simulation, mechanical and architectural design, medical imaging, virtual prototyping, games, and more. In fact, it is the engine that drives other Mac OS X foundation APIs such as Core Animation, Core Image, and Quartz Extreme.

OpenGL for Embedded Systems (OpenGL ES) on the other hand, is a simplified/subset version of the more-general API. It is designed, as the naming suggests, to be supported by many portable systems like the Android, BlackBerry OS, iOS, and more. OpenGL ES with respect to the iOS platform, is a primary reason why many great apps in the App Store exist today…

Thanks to the rapid evolution of both hardware and software, it is now more feasible and straightforward than ever before for both researchers and developers alike, to render complex scenes while relying on traditional fixed-function pipelines (OpenGL ES 1.1), or fully-programmable shader-based pipelines (OpenGL ES 2.0). Now with the addition of the GLKit framework that was introduced in iOS 5, developing highly-sophisticated, graphics-intensive apps is a breeze!

After this session is completed, it is assumed that following items can be delivered:

  • An overview of the key features provided in both the OpenGL ES 2.0 and GLKit frameworks,
  • A quick commentary on how to transition from OpenGL ES 1.1 to OpenGL ES 2.0,
  • Hints on how to improve the rendering loop using integrated performance tools, and
  • References to useful sources provided in the session…

Access to sample code, keynote slides, and other relevant material will be made available after the conference.

Developing for the Web in 2013: Creating HiDPI Web Sites

Tim Oliver, Edith Cowan University

Track: Web & HTML5; Audience: Intermediate

With the advent of the new Retina MacBook Pro, a new paradigm of HiDPI PC displays has started. As a result of this, a new set of requirements for creating and formatting visual content for these devices will start to become mainstream.

Based off several talks on Web Design from WWDC, this presentation will be around how to create websites that will look pixel-perfect on both standard display monitors and HiDPI monitors such as that of the new Retina MacBook Pro. This would include the methodologies behind creating such websites with new HTML5 and CSS3 standards, tips for testing it out on your current hardware, as well as general best practices to ensure stunning visual results.

Breathing life into dinosaur courses using DTrace

Chris McDonald, University of Western Australia

Track: Tools & Tech; Audience: Intermediate

The DTrace framework, available on Apple’s OS-X and other contemporary operating systems, enables a process’s execution and its interactions with the operating system kernel to be traced and annotated at a fine grain. DTrace provides well recognized benefits for systems administration, but also a great opportunity for Computer Science Education.

Computing textbooks employ many static ‘before-and-after’ figures, hoping to convey the interactions between programs and operating systems, and the transitions of internal operating system structures. Historically, Computer Science educators have hoped to breathe life into these textbook figures with purpose-developed visualization tools but, unfortunately, these have often required specific and unsustainable programming, compiling, and execution practices. Moreover, many of these tools have a constrained scope, or only support prebuilt demonstrations. These well-intentioned approaches often increase students’ cognitive load, leaving them confused as to what is to be learned.

This presentation will introduce the features and operation of the DTrace framework under OS-X, and outline our approach to improving the teaching of Operating Systems courses using dynamic tracing and annotation. In combination, we employ DTrace to trace the execution of programs, and graphviz and Tcl/Tk to visualize and review their execution. Instructive programs may be provided by the professor, developed and debugged by students themselves, or even be standard systems and application programs. Using this approach we can demonstrate, and students can investigate, concepts such as process execution and scheduling, file-system operations, interprocess communication, and networking. Students can directly learn from the execution of unmodified applications which run programs, manipulate files, and communicate with remote internet-based services.