He has written apps for the iPhone and the iPad since the SDKs first appeared and has written programs for the Mac all the way back to System 7.
Daniel presents iPhone, Cocoa, and Swift training and consults through his company Dim Sum Thinking. He is the co-host of the Tiny Challenges Podcast. When he's not coding or talking about coding for the Mac, the iPhone, and the iPad he's probably cooking or hanging out with his daughter.
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.
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.
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.
We know we should unit test our iOS apps but most of the frameworks make it so painful. The Kiwi framework uses RSpec- like tests. If you come from the OCUnit world the syntax and the style will seem a little odd but by the end of this session you'll see how easy it is to write your code and your nibs using TDD or BDD with Kiwi.
Design Patterns neither begin nor end with the Gang of Four. In this keynote we will begin and end with Patterns from their famous book but as with most after dinner treats the good part is the gooey center where we'll explore patterns that apply to Cocoa and Cocoa Touch apps.
The way you write code for your iOS and Mac OS apps has been changing with every release of Xcode. In this talk you'll see how recent changes dramatically alter your source code. With synthesize by default, literals, and the order of methods not mattering, the amount of code you write will shrink and what's left will be more readable. We'll look at before and after pictures that will convince you to embrace the new features that have been working their way into the language since Xcode 4.2.
Your users don't remember which device they were on when they created a new entry, edited an existing one, or marked some todo as done. In this talk we'll look at UIDocument and how to use it along with iCloud to keep your users documents in sync no matter which iOS device they're using. If you could dip your toe in a cloud, this would be the talk that shows you how.
You learned to love to use storyboards to layout and create your iPhone and iPad applications when they were introduced in iOS5. Now storyboards are back and better than ever. In this session we'll begin with a look at "our story so far". We'll then embark on a wild ride through new features in storyboards in iOS 6 including autolayout, localization, embedded view controllers, and unwinding segues.
Recently some marquis developers have blogged and tweeted about how they have finally embraced using blocks. Have you been reluctant to join this "Block party"? In this session we'll look at when and why we commonly use Apple's block based API in our code and then examine concrete examples of where and how we should introduce blocks into our own code.
iOS gets all the attention from the media but OS X is still getting plenty of love from Apple. In this session we'll look at what's different about programming the Mac. The visually obvious differences include apps with multiple windows and three notification centers. The code can look quite different as well. The Cocoa APIs are quite a bit older than the Cocoa Touch APIs and we also have a lot more memory and power available to us.
So much of the time we focus on what we do and how we do it.
We read books on coding, we come to conferences, we download open source and sample code, we read blogs and listen to podcasts.
During this session we'll explore why we do what we do and for whom. Whether you're inspired or depressed by this talk, you will think differently the next time you open Xcode and type Command-Shift-N and you'll pause before you upload your next app to the app store. Uploading is when you sign your name on your work.
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.
Details coming soon!
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.
Join Daniel for a session filled with best practices based on more than two decades of experience with the Swift Programming Language.
In this session we'll focus on a few of the features of Swift that will change the way you architect your classes and projects.
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.
Functions are the key to getting the most out of modern iOS programming in Swift. Building on the fundamentals of functions in C and blocks in Objective-C, Swift functions have the power and flexibility that will make your inner LISPer smile. This session takes you from Hello World to closures. We look at functions that range from those with the simplest of signatures to those that take advantage of generics.
You can’t just translate your Objective-C code to Swift and be done with it. You have to think differently. In this talk we’ll look at some of the patterns of programming functionally. In particular, we’ll introduce and explore three central higher order functions: map, filter, and reduce.
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.
We’ll look to the world of professional writers to improve the way you write code in Swift 2.0.
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.
When Apple open sourced Swift late last year, they invited the community into the discussion of where Swift should go and why. Instead of us having to imagine what the Swift language and library stewards and architects are thinking, we can read their words on the Swift evolution mailing list. In this talk we’ll look at what idiomatic Swift will look like when Swift 3 is soon released and talk about the reasoning behind some of the choices.
You have a problem to solve. It’s what we do.
You know you aren’t the first person to face this problem. In fact, you think that maybe you’ve solved this exact problem in the past.
How do we capture and share these lessons from individual projects or years of coding so that others can benefit from them.
Creating Swift Playgrounds without (too many) Tears
There’s no kit from Ikea for putting together a Swift Playground. The process will certainly get easier as Apple releases development tools, but for now we’re building it from scratch. You have to plane the wood, cut it, sand it down, fasten the right sort of hardware, and put it together yourself. In this session we’ll see what it takes to create and deploy even the simplest Swift Playground.
We’ll use the dying world of FM radio to understand how to schedule and spend our time.