This fast-paced day highlights concepts, syntax, and the latest best practices for the most recent version of Swift. If you are an experienced developer who hasn't had a chance to look at the new Swift Programming Language, this workshop is for you.
We'll look at language fundamentals: functions, variables and constants, collections, control-flow, optionals, generics, and closures. We'll look at Swift classes, objects, protocols, structs, and enumerations.
We’ll use the new Swift 2.0/ Xcode 7 Playgrounds to explore and experiment with Swift code.
There will be several hands-on portions of this workshop. To fully participate in those, you must have the Xcode 7 beta installed on your Mac.
New to iOS programming? This full day, hands-on tutorial focuses on the fundamentals to get you up and running. Over the course of the day, you’ll build two iOS apps while learning about the core tools, frameworks and concepts you need to start building apps of your own.
A look at the evolution of App Camp For Girls, from original idea in 2011 to App Camp 3.0 coming in Summer 2015. The process has been a continual learning experience and the lessons are applicable to any big endeavor, including your next app.
Jean will talk about where big ideas come from and what to do with them; how and when to start something new; building an audience for your idea; listening to feedback; iterating the execution; when to be flexible and when to be resolute.
Your software has bugs, guaranteed. You'd like to find them before your customers do. In this session, we’ll talk about testing strategies (including getting other people to find bugs for you!) and how to clearly report the bugs you find. This talk is accessible to all experience levels.
Graphics on iOS and OS X isn't just about stroking shapes and paths in Core Graphics and trying to figure out OpenGL. The Core Image framework gives you access to about 100 built-in filters, providing everything from photographic effects and color manipulation to face-finding and QR Code generation. It can leverage the power of the GPU to provide performance fast enough to perform complex effects work on real-time video capture. But even if you're not writing the next Final Cut Pro or Photoshop, it's easy to call in Core Image for simple tasks, like putting a blur in part of your UI for transitions or privacy reasons. In this session, we'll explore the many ways Core Image can make your app sizzle.
When Apple Watch was announced on September 9, 2014, Black Pixel had already been doing extensive research and design work for an iOS wearable. Of course, given that the Apple Watch wasn’t suppose to ship until 2015, we faced a number of problems designing for it. In this talk, I’ll go over our experiences designing for the yet-to-be-released device including how we used 3D printed models to explore use-cases and how we created prototypes to explore interaction design.
Apple’s initial WatchKit SDK is limited and powerful at the same time. Most of the processing for a third-party Watch app happens on a paired iPhone with data sent to and from the watch via Bluetooth Low Energy. This design leads to an API that emphasizes compile-time configuration and uses an interesting proxy-based approach to run-time user interaction. The design also requires most apps to implement some form of data syncing between the Watch app and its host iPhone app.
In this talk I’ll cover the basic architecture of the WatchKit SDK and share the code for an Watch app that uses many of the SDK’s features. I’ll also discuss some options for syncing data with an Watch app.
The MVC architecture is an enduring favorite of iOS development. However, what if it’s not the best way to architect your app? What if other acronyms like MVVM or VIPER hold the key to adding features easily and minimizing the dreaded “Massive View Controller”?
In this introductory talk, we’ll walk through several apps and explore the pros and cons of the MVC, MVVM, and VIPER architectures. To cap it off, we’ll dive into a real-world example of how Coursera is re-architecting its app for greater extensibility and discuss the benefits and challenges we’re facing as we move from MVC to VIPER.
Now that the winds from the iOS 8 storm have died down a little we can take a step back and review what has happened. There are loads of great headline features such as extensions and handoff, but what about the lesser-known additions? Some of them are cool new features, whilst some of them will have broken your existing app.
This talk will take a run at the underdogs of iOS 8 new features - first discovering why your apps no longer function as you’d expect, before exploring a few quick-wins to enhance your apps. We’ll cover topics such as notification actions, updates in XCTest, presentation of alerts & popovers and more.
You know you should be using NSLocalizedString in all your user-facing text, but how *exactly* is your app going to break the first time you translate it for real? (Be honest: how creative have you been with format strings?) We'll have a heart-to-heart about key-value pairs, create .xliff files that you & your translators can actually use, and enjoy a lovely romp through grammar issues that will haunt your best dreams.
The response to Reactive Cocoa (RAC) has been divided since we released it. People have either fallen in love, or been hugely skeptical.
I'm with the skeptics… or at least I was.
Programming has always been a means to an end for me. I wanted to build products and ship apps. Learning a new programming language, technique or tool because someone gave me a vague reason, such as saving key presses, never made sense to me.
When @joshaber first showed me RAC I was dismissive, but it didn't take long for me to fall in love.
In this talk I'll show how I was turned from a skeptic into a huge fan of RAC and MVVM using examples pulled straight from production code.
Recent iOS releases have added a lot to this key UI element. Give the table views in your app a modern makeover by taking advantage of features and adjusting to subtle changes in appearance and behavior. We'll do a live makeover—add Dynamic Type and dynamic row sizes, modernize the selection appearance, update Storyboard settings and other bits of polish needed to make a table view shine. We’ll also take a look at adding search to your table view using the new UISearchController.
Functional programming is finally a first class citizen in the Cocoa toolset! But, Swift is not necessarily a pure functional language. And in embracing the functional paradigm, do we need to throw out our knowledge and experience with Object Oriented programming? It turns out we can have our cake and eat it too!
iOS 8 introduced a powerful new feature called extensions. In this session we’ll cover the various types of extensions you can create and talk about potential impact. We’ll discover how you can leverage app extensions to create better user experiences for your apps. Finally we’ll build our own app extension to see how the rubber meets the road.
Since their release, Playgrounds have provided a safe place for experienced developers to experiment with syntax, algorithms, and techniques in Swift. The new and improved Playgrounds take us to a whole new level. They are the perfect environment for sparking interest in programming and for teaching programming to those who have never tried before. In this session I'll demonstrate some first steps in this direction and encourage discussion on where we can and should go next.
The rules we agree on define the games we play. We see this in methodologies we adopt for software development, in the mathematics we were forced to learn in high school, and in the syntax and grammar of the languages we choose to use.
During this talk we'll explore cases in which the implication of axioms are clear and cases in which they are far from clear.
There will be a quiz.
When the first 128K Macs landed in 1984, it was the first time many of us could undo a mistake with just a keystroke, or exchange data between documents or applications with cut/copy/paste and the system clipboard. Fast forward 30 years and we all use this stuff… but do you know how to actually implement it? Especially on iOS, these everyday features are surprisingly absent from many developers' toolchests. In this session, we'll flashback to the era of Reagan, Rubik's Cubes, and Return of the Jedi, to see these hot hits of the early 80's are represented in modern-day Cocoa.
Break dimensional barriers by mixing the 2D game API SpriteKit with the 3D graphics API SceneKit! Each of these SDKs has hooks to use the other one and we will explore how they can work together. We will augment 2D games using 3D graphics with SceneKit, see how to add 2D overlays on our 3D content, and explore using SpriteKit's texture generation facilities with 3D models. Detailed knowledge of either SDK is not required.
We’ve had about 10 months to dig into Swift. While that doesn’t really make anyone experts in the language yet, we (as a community) have begun to identify some interesting parts of the language that makes solving problems slightly different from Objective-C. In this talk we’ll dig into some common problems and solutions and see how we can do things the Swift Way. Our goal is to help uncover what eventually might become known as “Idiomatic Swift”. This talk will assume that you’re at least familiar with the Swift’s general syntax.
Swift wasn't designed in a vacuum, working with the rich history of Objective-C frameworks was a critical part of the design. We will see how you can work with both languages in the same project, what works well and what the pitfalls are. You will also hear about the real world experience of adding Swift to a large consumer facing app with millions of users.
The session will focus on a number of examples of things Swift is particularly good at or designed for, looking at specific problems you might encounter in app development, and contrasting Objective-C and Swift approaches for tackling them. We’ll peel back some of the jargon for folks who aren’t necessarily programming language enthusiasts but rather are looking for ways to apply, or even justify, use of Swift in active projects. From generics to lazy loading to decisions between reference and value types, come prepared to take away tips that you can use in solving the problems you face every day as a Cocoa programmer.
The speakers here at CocoaConf can talk for an hour or more on a variety of prepared topics --- but we bet they can't talk for an entire minute on topics we spring on them. Based on the long-running BBC game show "Just a minute", our panelists need to speak for a minute on topics suggested by our host and by the audience without hesitation, repetition, or deviation.
Jaimee will talk through some common and maybe not-so-common client and team situations, and some creative solutions for how to handle things when they seem to be going every way but right.
Bring your questions, ideas, frustrations, solutions and experiences to share at this super-fun open forum style session with Jaimee.
There are a lot of reasons why Storyboard is typically considered a toy rather than a full fledged tool for use in real world projects. Many of the recent changes to Storyboard have brought it up speed. This talk will explore how Storyboards can be used effectively to make building projects of all sizes easy.
UIKit Dynamics is an exciting resource from Apple that can bring charming interactions and behaviors to your iOS applications. In this talk we will take an advanced look at the framework and see how to solve common problems in the application of dynamics to real-world interfaces. During the session we will dissect a sample iPad application that makes heavy use of UIKit Dynamics. We will cover common counterintuitive notions and a variety of issues to avoid as well as useful work arounds. Finally, we'll learn how using dynamics often requires a unique perspective. A basic familiarity with UIKit Dynamics is assumed.
Watch this short video of the sample application that will be used.
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.
Many people have experienced a WTF? moment when first hearing about size classes. There’s no denying that the way they are designed is one of Apple’s more inscrutable decisions in recent memory. However, there is a lot that is good about them, and some techniques which can make them more useful than they first appear. We will learn what they are and how to work with and around them. Basic familiarity with Auto-Layout is recommended but not required.