Josh has 20 years of professional IT experience and has been a sysadmin (and still kinda is), programmer in various languages, consultant, employee and guy who makes sure the pop machine is full. He lives, works, and occasionally builds robots in Pittsburgh, PA.
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.
So, you’re thinking about your app and then you realize that Your Awesome App would require a huge amount of infrastructure. You’d need a highly scaleable database, web servers, a bunch of other stuff like Queues and the ability to send email. You could build all of this yourself, but that is something even experienced systems and DevOps people mess up. Fear not, Amazon provides an excellent SDK to provide cloud services for iOS apps. In this introductory session, we will give an overview of the services you can access in the Amazon AWS SDK and how you can add cloud services to your app quickly and easily. This session will focus on Amazons Simple DB (SDB), Simple Storage Service (S3), and Simple Queue Service (SQS) and will use these services to build a real-world application.
OpenGL has long been the industry standard for doing things that most programmers never do. This introductory session will present GLKit, show you when it's appropriate to use and what you can accomplish with it.
NSPredicates aren’t just for Core Data. NSPredicates can be used to attack a variety of tasks with collections in ways that make your code more testable and easier to maintain. They are, however not well documented and notoriously difficult to create. Sure, once created they are easy to use and let you do things that are very difficult without them. In this intermediate session we will cover what NSPredicates are, where they can be used, how to debug them, and how to replace difficult to maintain iterative code with elegant predicates. You should have a good understanding of Objective C and the collections. While we will cover some of Core Data, this is not a Core Data session.
Special purpose programming languages are anything but new. The same with extension languages (for example, TCL was created in 1988). In this session you will learn the difference between these two concepts and learn how you can leverage these concepts in iOS and Cocoa applications. We will also cover how to include them in your XCode workflow.
This workshop is for people who are past the basics of iOS development and are interested in developing 2D games. When you finish, you will have developed two mini-games and have an understanding of how to prototype and test game ideas and mechanics. We will also cover how to prototype physics games and integrate Apple's Game Center and Game Kit device communication into your apps.
When we are done you will be able to:
This is an intermediate session, and it is assumed that attendees are iOS developers. At a minimum, you should know how to build and run apps, link and use iOS frameworks. You should have an Apple computer with Xcode 4.6 or higher. Being able to deploy to an iOS device during the session is optional, but may be helpful. You should also bring an iPad with at least iOS 6.1 and install the Codea application that we’ll use throughout the workshop.
Familiarity with Lua will be helpful but is not required
Sure, you've used NSArray and NSDictionary. But this talk is about the some of the less popular members of the Collections Classes. I'll be talking about NSCountedSet, NSEnumerator, NSIndexPath, and NSIndexSet. This is a class for those who may be new to the Foundation classes and will provide a better understanding for some of the excellent classes available in the Collections Classes.
This is a one hour very basic discussion about improv and the modern programmer. This is not a presentation and you will be required to participate. But fear not! It will be fun and you will leave with a better understanding of how improv comedy techniques can turn your Hamlet of a meeting into a Midsummer Nights Dream.
This workshop is for people who are past the basics of iOS development and are interested in developing 2D games. When you finish, you will have developed two mini-games and have an understanding of how to prototype and test game ideas and mechanics. We will be covering Sprite Kit and its physics engine.
When we are done you will be able to:
This is an intermediate session, and it is assumed that attendees are iOS developers. At a minimum, you should know how to build and run apps and use iOS frameworks. You should have an Apple computer running Mavericks with Xcode 5 or higher. Being able to deploy to an iOS device during the session is optional, but may be helpful. This requires an iOS device with at least iOS 7.0.
Sprite Kit is one of the most exciting frameworks Apple has ever released. It can also be used for things other than just games. This talk will cover using Sprite Kit in UI Kit applications to provide interactivity and gamification. This talk does not require any Sprite Kit experience.
Welcome to the All New iOS Game Development Tutorial. We'll be teaching you the ins-and-outs of the new Sprite Kit Framework shipping in iOS 8 as well as how to write games using the toolchain Apple provides. Most of the coding will be done using Swift, though this is not an intro to swift session. You should be familiar with both Swift and Objective C to get the most out of this tutorial.
Concurrency in Core Data is one of the most misunderstood parts of the system. I’ll be talking about the new concurrency handling available in iOS 8 as well as best practices to make sure your Core Data application is threaded correctly and you can concurrently do things safely and performantly. Some of the examples will be in Swift and some in Objective C.
If you’re not using UIManagedDocument you should be. The days of managing your own core data stack are long gone, managed documents are the easy solution to many of your core data problems. This talk will demystify managed documents and show you how, when, and why to use them in your application, even when your application isn’t a document-oriented one. This introductory level talk assumes no prior experience with Core Data and examples will be in Swift and Objective C.
What is SQLite? Why do we care? After all, we have Core Data, what more could we need need in life? Well, it turns out that sometimes you might need a file format for storing data to disk and you might not want to use core data for it? This introductory talk will cover how to decide between Core Data and SQLite (hint, you don't choose, really). It will also cover how to code using the SQLite api in Swift, C++, and Objective C.
GameplayKit is a huge release from apple. It includes a mind-boggling huge list of features and useful things. This intro presentation is going to focus on the state machines that GPK provides and how you can use them in both game and non-game apps alike. Come for the State, stay for the machine!
Have you ever though about putting a rule engine in your app? Or have you written one, only to long for the ability to have some new feature or some fuzzy logic? Well now everyone can do it! GameplayKIt includes a fuzzy logic engine that you can use in your games and non-gameapps. This mid-level presentation focuses on rule engines provided in this framework and how you can use it in your own development. The probably is high that you'll enjoy this session.
The motion coprocessor found in iOS devices is a hugely powerful sensor package. This introductory session will introduce the motion apis and show some of the cool things you can do with them. Be amazed as we weigh someone just by jumping and find out why such a sensor is useful for real work.
GamePlayKit offers a giant bag of awesomeness for game developers. This session covers Pathfinding, Agents and Goals, and the simple AI tools provided in the GamePlayKit framework. This session will show you how you can use these tools in your games to reduce the amount of code you have to write and provide an awesome play experience.
In this advanced talk, you will learn how to build voice and speech systems using both 3rd party and Apple frameworks. Voice and Dialog interfaces are very different from the UIs developers are commonly to. This talk will also cover an overview of how to build dialog system and where the state-of-the-art is still (sometimes) lacking.
Torch7 provides a Matlab-like environment for state-of-the-art machine learning algorithms. It is easy to use and provides a very efficient implementation, thanks to an easy and fast scripting language (Lua) and a underlying C implementation.
In this moderately advanced tutorial I’ll be covering how to use Torch7 on iOS to construct simple neural networks and do some cool stuff.
Micro services architecture is an approach to software development where a single application is composed of many small services, each running in its own process space and communicating via lightweight methods. Micro services used to be really hard to deploy but that’s not true anymore. Now we can even write them in Swift.
In this talk we’ll cover how micro services can help you as a developer and how to make them in swift. We’ll even talk about two ways to deploy them (one using a serverless system called OpenWhisk from Apache and the other using Docker swarms).
This is an introduction to Maps, Coordinate Systems, and cool tricks you can do with them. This introductory session will cover the basics of working with maps, what coordinates do and how to use and convert them, and how to draw paths on maps using sensor data.
Isn’t that what everyone wants to know? How do you estimate how long an a feature or system is going to take to complete? We know that estimates are often wrong, but can’t we say something?
Maybe, we can.
We’ll talk Monte Carlo solutions, estimation history, and why communicating error in measurement is important.
Sure, everybody likes Metal but the Accelerate framework is where the magic really happens. This talk assumes no prior usage of BLAS or Fortran.
We’ll talk some Math, some Matrices, some Ceiling Wax and Kings.