Add an eventCocoaConf schedule
Friday 12th August 2011
-
iOS Tutorial
During the all day iOS hands-on tutorial, we will do soup to nuts iOS development. We will start with how to use XCode and build a universal application for iPhone and iPad using a variety of common APIs. We will finish up talking about and demoing how to prepare and deploy to the app store. The app we build will allow us to experiment with a bunch of APIs including Core Data, Camera, and more.
-
Objective-C Runtime: Fun Under the Covers
by Craig Castelaz
The Objective-C Runtime lies at the very heart of the language. Its the "object" in Objective-C, and makes possible important language features such as introspection. In addition to objects and introspective, the Runtime enables Categories and Swizzling, two ways of extending and modifying objects that aren't yours. There are even limited, but easy to implement optimizations available with a little knowledge of the Runtime Its possible to write great Mac and iOS apps without ever directly addressing the Runtime, but things are a lot more interesting and fun under the covers.
-
UI Automation - Testing From The Top Down
UI Automation is Apple's blessed UI testing framework. You manipulate your app through the UI with Javascript, not too unlike the way you manipulate a web page. Tests can run in the simulator or even on the device. It's a powerful and flexible system that can look overwhelming at first. We'll introduce the framework and walk through some good practices to keep your tests organized as they grow.
-
NSURLConnection and Beyond: Networking with Cocoa
by Steve Madsen
Ubiquitous access to a network has changed how the world thinks about personal computing, and we're seeing it happen for a second time on mobile. Cocoa provides a rich set of networking APIs. This session explores the options available on Mac OS X and iOS, including NSURLConnection, GameKit and popular third-party libraries, and the special considerations developers should understand for mobile.
-
Performance Tuning
We all want our apps to perform better. Run faster. Consume less memory. Burn less battery. Sometimes it's hard just to figure out what our performance problem _is_, much less fixing it. This session will cover common performance problems on iOS and Mac OS X, how to track down problems using tools such as Instruments, and ultimately, how to get the mindset to get your apps fast, and keep them there.
-
DTrace: Its Not Your Father's Debugger, ... or His Profiler for that Matter.
by Craig Castelaz
DTrace is frequently billed as the SysAdmin's friend. While its certainly a great tool for SysAdmins, they're not the only group who can benefit from this amazing technology. Both Mac and iOS developers can make use of DTrace, and its far easier than many imagine. This course covers a wide range of techniques, from writing one-line DTrace scripts for quick-and-easy debugging and profiling, to actually incorporating DTrace into your application. Learning DTrace from an Objective-C perspective is a wonderful reminder that tomorrow belongs to all of us, not just SysAdmins
-
Understanding View Controllers
by Bill Dudney
UIViewController and it's various subclasses are a key part of any iOS application. Come to this session to learn about the view controllers lifecycle, and the lifecycle of the view it controls. You will also learn about how view controllers help your content to rotate when the device rotates.
-
We Made An App For That
This is your chance to shine! We'll take a quick look at several apps written by attendees with an explanation of what made the app interesting, challenging, scary, or just plain fun to write. Any attendee will be able to submit an application and a panel made up of our speakers will choose the final slate of apps. Mark Gilicinski will be moderating this session.
-
Introduction to AV Foundation Level: Intermediate
AV Foundation, introduced in iOS 4, offers broad and deep media functionality to third-party apps. Working from a "media document" model, it provides APIs for audio and video capture, editing, playback, and export. Developed in parallel with the iOS version of iMovie (which it powers), AV Foundation is a sensible first choice for most media needs on iOS, and is so compelling that it is being added to Mac OS X in Lion. In this session, we'll survey the kinds of features AV Foundation provides (and note the cases where you'd want to use something else, like Core Audio), and then dig into the basics of its capture, playback, and editing features.
-
iOS Game Development with Cocos2d
by Josh Smith
Apple's iOS is a great platform for developing games. However, Cocoa Touch lacks some featuers that would make it much easier to write 2d games. Cocos2d provides most of those things (note that Cocoa and Cocos are not related in any way). Cocos2d is an Objective-C framework for building 2D games, demos, and other graphical/interactive applications. It is very well documented and easy to use. It is also very fast and has a friendly license (it is used by many popular games). This session will demonstrate the creation of a simple 2d game using Cocos2d for the iPhone/iPad (developing universal apps will be covered). The game will also use the audio engine from Cocos2d for sound effects and music. This session will provide a solid introduction to using Cocos2d for games and media-intensive applications for the iOS platform.
-
Advanced AV Foundation Level: Advanced
The iOS version of iMovie uses the AV Foundation framework, and indications are that Final Cut Pro X will be using the Mac OS X version of AVF. And if AV Foundation is powerful enough to provide the core functionality of Final Cut, it must have some great stuff going on, right? In this session, we'll dig into the more powerful (and more challenging) APIs in AV Foundation, including reading and writing raw samples, performing live processing of incoming data at capture time, and advanced editing features like mixing audio and video tracks and adding Core Animation-based titles.
-
Test Driven Development in the iOS World, Part One
Test Driven Development (TDD) is an approach to development that uses automated software tests to drive the design and development of an application. It allows developers to focus on one thing at a time -- to tend the individual trees in the forest without destroying the forest itself.
This session will:
- discuss some pros and cons of TDD in the iOS world,
- consider what thinking about development in a "test first" manner entails,
- work through the initial steps of developing an iOS app using TDD techniques.Other sessions discuss some of the automated testing tools available for iOS in more detail, so this session will focus on using the tools, not the tools themselves.
In part one, we will begin developing a simple game using TDD techniques, focusing on testing components with no dependencies.
-
Keynote: Your Code - the Director's Cut
When you build your application it's like a director on a movie set yelling "Action". There are all sorts of objects appearing on screen, there is dialog, and there is plenty of action. Your source code is like the shooting script for an action packed movie. From simple method calls to delegation, you are trying to get the most out of your objects. We'll take a brief look at everything from object creation to MVC from the vantage point of the director.
Saturday 13th August 2011
-
Blocks
Blocks is a relatively new language feature that will change the way you code. They were made available for iPhone programming with iOS 4 a little more than a year ago and were added to the iPad with the release of iOS 4.2 Mac OS X developers had an extra year to embrace blocks. In this session, we'll look at why you want to use blocks and when you will most often use them. We'll examine the syntax of blocks but we won't dig deep in to the subtleties.
-
Intro To Mapkit
Because iOS devices are location aware, many applications include maps and annotate specific points with pins. The presentation shows you how you can add maps, custom annotations and driving directions to your iOS applications by incorporating the MapKit framework.
-
Keeping Secrets for iOS Developers
by Randy Beiter
iOS applications frequently miss the mark on securing data whether the user's or the application's itself. Are you using SSL for talking to a remote API but embedding the credentials for the service cleartext in your application bundle? Securing user data behind a strong password but storing it in the open on the device's filesystem? Charging for premium content already delivered with your app and expecting code signing to protect it? Did you know data you store in the Caches directory to avoid backups can be browsed using a free tool even without jailbreaking? Learn some tips and gotchas to keeping secrets with the iOS SDK at this session geared for the iOS developer but potentially useful to any mobile developer.
-
Mac OS X for iOS developers
Just a few years ago, Mac OS X developers were making the transition to coding for the iPhone. But then the flood gates opened and people flocked to the platform just to program the iPhone and iPad. Now it's time for them to consider making the transition to Mac OS X. In this sessions we'll look at what's different about writing code for the desktop. Some of the conventions are different and some of the technologies available are different. This session will smooth your way from producing apps for the App Store to creating desktop apps for the Mac App Store.
-
MacRuby
Ruby has made quite a splash recently. It's not a new language, but its popularity grows as the Ruby community creates effective conventions from the amazingly flexible syntax. Best known for Rails, the rapid development web framework, Ruby caught the eye of Apple and they forked it to make the open source MacRuby project. Under the hood, Objective C shares a lot in common with MacRuby. We'll explore these similarities and we'll learn a bit about how it interacts with Cocoa. We'll also get a taste of the flexibility by looking at some patterns and conventions that have emerged (as well as some pitfalls) and how they might translate to the Cocoa environment.
-
Unit and Functional Testing for the iOS platform
You know unit and functional testing is important, but as an iOS developer you are probably not doing it. There are a lot of reasons why not: poor documentation, difficult to get started or maybe you didn't even know it was possible. This presentation won't bore you with why you should test. Instead it will focus on practical tips and frameworks for getting you started in building better more reliable applications for the iPhone, iPod Touch and/or iPad.
-
Drawing with Core Graphics on iOS
by Bill Dudney
Core Graphics is a fundamental piece of iOS. Come to this session to learn how to use this powerful API to add great runtime built graphics to your iOS applications.
-
Using Game Center in iOS Apps
by Mac Liaw
Games is the most popular category of iOS apps. A game with excellent Game Center integration not only increase replay values, but also gives you a way to promote your app through words of mouth. Microsoft’s Xbox Live demonstrated how effective this can be. You can have it too. Game Center provides you in game persona, leaderboards, achievements, multiplayer support, and peer to peer networking. We’ll discuss how to effectively use Game Center in your app, and the examples of well executed in-game achievements.
-
Xcode 4.x
by Dave Koziol
If you are writing native code for iOS or Mac OS X, Xcode is the tool you are most likely using. In this session, you'll get oriented to where things are, and how to move along, and then move on to an introduction to some of the more advanced features, or commonly asked questions. You'll learn how to customize some of the behaviors of Xcode to match your preferences, how to work with multiple targets, sub projects, and how to use schemes for world domination (or maybe just to develop more productively)...
-
iOS Development using Lua and Wax framework
by Mac Liaw
You just got a great iOS app idea. You are convinced once your app is released on App Store, you’ll make millions of dollars. Fame and fortune will follow. You’ll be the next geek hero. All fired up, you download XCode, iOS SDK, pay your $99. Ready to become the envy of your peers. Then you stared at Objective-C. “No Problem, I can power through this.” But days turns into weeks, weeks turn into month. If only there is a more productive way. You start exploring various scripting language solutions, only to find out that none of them can really integrate with the Objective-C runtime very well. Until now. Lua with Wax brings GC, dynamic language and full access to the entire Cocoa framework. It also has bultin REST support, closure and pattern matching. Now you can resume the dream of becoming the next geek hero!
-
Test Driven Development in the iOS World, Part Two
In part two of our TDD journey, we will build on the simple game we began in part one, and practice thinking in a "test first" manner.
We will move beyond simple components and look at how we can use TDD techniques to test components with external dependencies. We will explore a few techniques and tools that help us do that without turning our test suite into a quagmire of hopeless complexity.
-
Thoughts About Debugging
Oftentimes, what separates an average developer from a great developer is the ability to debug. When faced with software that Just Doesn't Work, how do you go about finding the problem quickly and fixing it? In this session we'll cover some tools and techniques that can improve your debugging chops.
Schedule incomplete?
Filter by Day
- Friday 12th 13
- Saturday 13th 12