Rob is co-author of iOS Programming Pushing the Limits. Before coming to Cocoa, he made his living sneaking into Chinese facilities in broad daylight. Later he became a Mac developer for Dell. It's not clear which was the stranger choice. He has a passion for the fiddly bits below the surface, like networking, performance, security, and text layout. He asks "but is it good Swift?" a lot.
You’ve done the AES thing to your data, so now your app is secure, right? No. Many (possibly most) iOS programs that use AES use it incorrectly and insecurely. Some of the most popular examples on the internet are unfortunately wrong. Are you confused about how to handle the IV and salt? Do you just ignore them? You need this session.
Do you think AES alone protects your data from tampering? It doesn’t. Your “$10” field can easily be changed to “$50”, even if the attacker doesn’t know the password. You need an HMAC to protect against that. Never heard of an HMAC? You need this session.
Self-signed certificates are dangerous, right? Wrong. They can be more trustworthy than that commercial certificate you’re paying for, but only if they’re managed correctly. Improve security and save money at the same time. What could be better?
Veteran security risk assessor, Rob Napier, will show you how to avoid these and other common security mistakes he’s seen in product after product. This session will focus on issues impacting iOS, though most of them apply equally to OS X.
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.
Drawing rich text, particularly editable rich text, has long been a real problem for iOS developers. No longer! iOS 6 finally integrates the kind of rich text capabilities that Mac developers have used for years. Previously neglected NSAttributedString is now the heart of rich text throughout UIKit. In this session you’ll learn your way around fonts, decorations, paragraph styles, text direction, and more.
But powerful as UIKit is, sometimes it just isn’t enough to get the kind of text layout you want. That’s were Core Text comes in. We’ll move through the entire stack from framesetters to glyphs. What’s leading? What’s the difference between a character and a glyph? Why is Core Text laying my text out upside down? You’ll find the answers to these and discover the world of ligatures, advances, font metrics, and text matrices. By the time we’re done, you’ll be able to get just the layout you want and keep your text readable and beautiful.
UIKit Dynamics is new in iOS 7 and the rough edges still show a bit. It’s quirky. It’s backwards. It can be maddening. But it also can give you some very cool UI effects that are tricky to get other ways. UIKit Dynamics is the habanero of iOS. Too much will make you cry, lose your hair, and possibly hallucinate, but just enough can be exciting and delicious. In this session, you’ll go deep into this new frontier, learn the lay of the land, and tame the wilderness. Rob will rant a little bit, and then we’ll explode some stuff.
In the US, the llama is an exotic zoo animal, with an odd appearance, funny name, and strange habits. But in Peru, the llama is an everyday pack animal, useful for getting things done. Functional programming is much the same. At first look, from an object-oriented culture, it can seem strange, filled with confusing jargon and weird operators. But ultimately, Functional Programming is programming. It’s a tool for getting things done. All it requires to be useful and practical are a few new ways of thinking about problems, and a few language features that Swift provides.
This talk will teach you what you need to get started solving real-world problems with functional solutions in Swift. We’ll focus on common Cocoa issues that functional programming can simplify, like error handling, JSON parsing, and asynchronous network operations. You'll learn to make your programs more robust, easier to maintain, and easier to reuse. To get the most of this talk, you should have a basic understanding of Swift. Daniel Steinberg's Swift Kickstart covers everything you need to know.
When should you use a Sequence versus a Collection? What's the difference between a Range and an Interval? How do you build a Generator, or should we say Iterator? And what in the world is a Zip2?
The Swift standard library is full of types and protocols, and it can be a bit overwhelming. We'll walk through them, learn how and when to use them, disucss changes coming in Swift 3, and demonstrate a few pitfalls for the unwary and tricks of the enlightened.
The Swift stdlib comes with some very useful Collection types. You probably use Array and Dictionary in every app you write, maybe Set from time to time, and Range without really thinking about it. But there is so much more to Swift Collections, and even more coming in Swift 3. In this session you’ll learn how to build your own Iterators, Sequences, and Collections, and all the free methods you get for your trouble. And you’ll learn how to write cleaner code using powerful tools like map, flatMap, filter, and enumerated. C-style for loops are going away. If you’re still using them, you’ll want to attend this session to learn the many powerful Swifty alternatives.
When you think of the stdlib, you probably think first of the Collection types, like Array and Dictionary. And they’re definitely very important. But there’s much more to the stdlib beyond the generic collections. There are numbers and strings and mirrors and strides and zippers. If you’re ready to go a little off-road, there are the unsafe and the unmanaged. There are convertibles and hashables and the surprisingly tricky equatable.
The Swift stdlib is a rich and varied place, and in this session you’ll visit many of its lesser-known corners. Everything but Collections. That’s enough for a talk of its own. (See “Beyond Array. Getting the most out of Swift Collections.”)
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.
Details coming soon!