The less time we spend debugging, the better. XCode offers much more than just a strategically placed call to NSLog. This talk will introduce you to some powerful but lesser-known debugging strategies and tricks. We will begin by exploring the advanced features of breakpoints, and how to use the strengths of the Clang expression parser to inject code into an app being debugged. Next, you will learn how to use XCode's new visual memory debugger to hunt down leaks. Finally, you will see how to extend LLDB to debug views and run external commands on JSON fetched from web services.
Many people, including myself, were really excited when Metal was announced in 2014. We thought about all the neat graphics programming we would be able to do. Then we watched the WWDC videos and ran into a wall of jargon. What the heck is a command encoder? What does that have to do with graphics programming??
In this session we will demystify some of these concepts and show how they contribute to the images you see on the screen. If you've had some trouble getting off the ground with Metal this will give you a nudge in the right direction.
Headed up by IBM, Kitura is an open-source, scalable web framework that uses Swift in order to create web services on Mac or Linux. If you're an iOS Developer who is interested in backend web development but don't have the time to learn another language, Kitura offers the chance for you to set up your own API for your app while sharing model objects between the server and the client. We'll be going over basics, setup, and common use cases for this fast-growing framework.
Today's handheld computers are machines with amazing capacity for storing and processing data. With the most memory and highest bandwidth the world has ever seen, combined with easily used general purpose compression algorithms, the use of human-friendly data encodings such as JSON has become nearly universal.
This works great, until it doesn't. Whether you're using a low-speed mobile data connection, working with peripherals that must minimize radio power usage, or simply working with large data sets, there may come a time where saving a byte or two is vital.
In this session we'll explore various methods of storing only the minimum number of bits required to express a piece of information, including bitmasks, sub-byte fields, and run-length encoding... and the portability woes you may face.
Got an idea for a great macOS or iOS app, but you need a backend API to make it work?
In this session we’ll see how easy it is to get up and running with a backend server side API in a language you’re already familiar with, and even use the same backend API to serve data to an iOS app and a web frontend.
Let's get down to bits and bytes! Abstraction is great, but sometimes it's useful to dig down. In this session, we'll explore exactly how Swift lays out data in memory, including both your own variables and Swift's internal data structures. We'll build a program to recursively scan memory at runtime to dump out everything we want to know, then walk through its results and what they mean, and compare and contrast with how C and C++ store their data.
With Facebook shutting down Parse, everybody knows to never again depend on a third party for their backend solution, right? Sure, and after you spend six months trying to write your own syncing service, how's that working? In 2016, Google has added a ton of features to Firebase, their popular backend-as-a-service solution. Firebase's primary offering is a realtime database in the cloud that syncs changes to and from multiple concurrent users, and their Swift-friendly iOS SDK makes it ideal for mobile use. In this session, you'll learn how to set up a Firebase backend and build an iOS app around it.
Apple’s interface builder gives you considerable accessibility for free, but developers, being creators, often will want something new.
In this talk, we’ll see how you can take advantage of accessibility in default UI controls when available, and approaches developers can take when making User Interfaces from scratch. We’ll talk about how to test for accessibility (beyond the simulator), and hopefully someone might be brave and let us test their app.
Let's explore directly programming the GPU using Metal and Swift. Enjoy giant speed gains in your existing code, and dream up whole new classes of apps.
It's not obvious how to even start thinking about this stuff. What kinds of problems can be attacked? What is the learning curve? What are the trade offs? We'll get things cleared up and start exploring with real code.
Swift-Metal playgrounds will be available to get your feet wet and start experimenting. You'll go home with a starting point for your own projects.
Animation timings and gameplay actions are controlled by numerical values. However, discovering those values is much harder than measuring the pixel sizes of static images from a designer. This talk provides ideas and strategies for how you can make working models in Xcode and which values are the most important when you are trying to decide how to delight your users with your animations and gameplay.
Leveraging the power of machine learning, image recognition APIs have become a powerful resource for system developers. There are a number of product offerings from IBM, Google, Amazon, Microsoft, and others. This talk compares and contrasts the APIs, performance, and most importantly, the accuracy of leading image recognition APIs. The APIs are not created equal and they don't perform equally. Some of the vendors excel at specific problems and struggle with others. This talk leverages several months of research and testing we performed to help you figure out which vendors may be best suited for your problem space.
Swift is not a functional programming language. Pushing too hard to make it one fights Swift and breaks Cocoa.
But Swift has absorbed some fantastic lessons from the functional world, and while value types may not quite be the present, they are clearly the future. We’ll explore how decades of work in functional languages have influenced Swift, and how you can use those features best while staying true to Swift.
Autolayout is nice, but can still be tedious and error prone. Stack views can come to the rescue, making most of your constraints unnecessary. At the same time they can make your user interface more dynamic, easily handing changes in device size, orientation, and even changing design requirements. In this session you’ll learn how to make the most of UIStackView in your apps.
Swift is great for writing iOS and Mac apps, and its creators also mean for it to be used as a systems programming language. However, certain traits about Swift make it officially off-limits for use in some audio/video-processing scenarios. What's the deal, is it not fast enough or what? We'll look at what media apps can and can't do in Swift, and what you're supposed to do instead. We'll also look at strategies for knowing what responsibilities to dole out to Swift and to C, and how to make those parts of your code play nicely with each other.
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 all day workshop will focus on strategies for debugging and the tools we have to find and exterminate the oddest of bugs in existing code. After reviewing our tools and some methodology for debugging; we will practice on contrived and real-world examples. We will tackle easy but common items first and then move on to harder examples involving memory pressure; wonky networks and race conditions. Then we’ll move on to truly bizarre problems that couldn’t ever happen in real life, could they? Attendees are encouraged to bring interesting bugs from their own work for the class to study.
Keychain, disk encryption, Common Crypto, certificates. Security can be daunting for Cocoa developers. There are so many frameworks filled with words you’ve never heard before solving problems you don’t understand. And why does so much of it have to be in C?
The truth is that good security is hard, but the code doesn’t have to be. This session will show you how to best use the many security tools Apple provides. You’ll learn how to properly encrypt with AES, how to make the most of iOS’s device encryption features, how to best manage SSL, and more. If you’re using AES for anything, but don’t know what an HMAC is, you need to attend this session.
Apple made major changes to the Notification APIs in iOS 10, affecting both Push and Local notifications. In this session, you'll get a high-level overview on what's changed, what you need to do to make sure your existing apps keep working, a few pitfalls to avoid during the transition, and some examples of the cool stuff you can do with the new toys.
Unless you've lived under a rock, you're familiar with the MVC architecture. It's been around since the 1970's. However, I would like to propose that the "M" as we know it isn't really necessary anymore. If you come to this session, I'll expect you have a basic understanding of MVC and then I'll propose to you we don't need the "M" anymore. Intrigued? Come hear me out. Dump the M. You don't need it.
People talk about accessibility, and if is an app accessible or not. While any attempt to make an app more accessible is appreciated, “totally accessible” doesn’t mean that it’s efficient.
In this talk, Kevin will show you how VoiceOver thinks, how it behaves, and explore the differences between accessibility and efficiency, and arrive at how it’s all really a spectrum that we all live on.“There are those with disabilities and there are those who haven’t quite found their’s yet.” --Chris Downey
Like riding a bicycle, TDD is something you learn by doing. In this hands-on workshop, we’ll start out with a simple exercise to learn the basics of the TDD Waltz. Then we’ll make things more complex, work with a view controller, and finally discuss ways to tackle legacy code. Bring your laptop!
This fast-paced workshop shows you how to take advantage of Swift features to write more robust code that is easier to reason about. We'll spend a good part of the day looking at functional programming and playing with map, filter, reduce, and flatmap but we will also create instances of classes, structs, and enums. We'll explore how your iOS app architecture may change when you embrace idiomatic Swift.
One of the strengths of Swift is that it can borrow the best from a multitude of paradigms. We'll look at how to successfully weave together OO and functional code into a readable and flexible architecture and focus on protocol oriented programming.
We assume that you are an experienced programmer who has spent some time looking at Swift but you aren't yet an expert in Swift. You understand most of the hows and whats of working with Swift and are looking for the whys and wheres.
Text and string processing is a subject that looks easy at first, but becomes tremendously complicated the more you look into it. Unicode is the modern standard for computer text processing, and it's full of complexity. In this talk, we'll take a deep look at Unicode's history, design, and structure. You'll learn about code points, code units, combining characters, normalization, emoji, UTF-8, UTF-16, and UTF-32. With this foundation in place, we'll bring it all back to practical applications by seeing how it fits in with Swift's powerful but sometimes complicated String API.
Many apps have some global state or services that need to be accessed at various places in code. In this session, we begin with singletons, and work through design iterations arriving at an approach using protocols and existentials Swift that make these global dependencies more explicit, while making subsystems that rely on the them more easily tested and evolved.
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.