Updated August, 2015
In this course, you will gain a deep understanding of Swift and WatchKit so you can develop your own Apple Watch apps! Whether you're developing an app from scratch, or you want to extend an already-existing application you've written for iPads and iPhones to support the Apple Watch, you've come to the right place! You will learn to do ALL of those things!
This course is both for new developers, and Objective-C developers who want to learn Swift!
What is this course about?
It's about building a solid understanding of Apple's Swift programming language, and then taking that knowledge to build your own Apple Watch applications! This course will be evolving over time, with added content being added often!
More importantly, I want to urge you to START NOW! Apple Watch is going to be the next big thing. I say this with a heightened sense of urgency! So many manufacturers (I'm picking on Android Wear users here!) have tried to develop smart watches that would really take off and make a splash, but it just hasn't happened. Based on Apple's history of hardware launches, as well as the design of Apple's Watch, you can bet that people with Apple Watches will be the centerpiece of conversation for a while. The sheer number of style combinations that will be at the release will appeal to a very broad range of people!
Why take this course, and why take it from me?
How is the course structured?
The 'Getting Started' section will talk about course structure in more detail. However, in short, each section has an introduction that explains what we'll be doing, and a conclusion to go over what we've learned. I use a presentation format to go over details about a topic, then I'll dive into XCode screencasts to show how to use what we've learned. Quizzes will appear at the end of each section. This applies for the entire course from start to end. Please preview some videos below so you know exactly what you're getting!
Lastly, I'd like to say thank you for taking a look at my course that I've created for you. I love talking to my students, so please know that I will always be available for support if any help is needed along the way!
*For every 500th paying student, I'll randomly select a student to receive a free Apple Watch Sport! Get in early to potentially have more chances to win. (Ex: If you're the 50th student, and I reach 1500 paid students, you'd have 3 chances to win!). Note that 30 days must elapse after joining this course before any prize is awarded. This promotion is valid for USA residents in the 48 contiguous states only. One entry per person. No purchase necessary to win.
Thanks for joining!
We'll be going through some of the requirements that will need to be fulfilled before taking this course like downloading XCode and having an Apple Developer license.
Let's set up a developer account and download XCode!
Here I'll go over how this section of the course is laid out and what to expect.
Here we talk about the improvements and features that Apple has implemented in the Swift language, over the Objective-C language.
How are variables and constants used in Swift? We'll discuss some simple types and how the compiler can choose a type for you!
In this video, we'll look at some pre-written Objective-C code and talk about some things that work a bit differently when moving over to Swift.
Here we'll write some Swift code using what we now know about variables, constants and types in Swift. We'll also show how to print variables with Swift, which works a bit differently from Objective-C.
Let's continue looking at different types of variables and constants. In this video, we look at how inference works, as well as an easy way to figure out what 'type' a variable is.
We talked a lot about the basics of Swift and how to define variables and constants. Take the quiz to really burn it into your brain!
What are optional variables? We'll take a good look at this new paradigm in the Swift language, that will save you from crash-happy code!
In this video, we'll use XCode "Playgrounds" to take a look at how Swift Optional Variables work.
Let's see what you learned about Swift Optional Variables!
Learn to modify values of variables or combine one variable value with another. Learn terms such as Unary, Binary and Operands.
Let's go through some pre-written Objective-C code that we'll then start converting into Swift. We'll talk about different operators such as ternary, unary, arithmetic, remainder and more.
Here we continue writing Swift code to experiment with Operators. Unary, binary, ternary, compound and basic arithmetic operators in Swift are some of the things we'll discuss in this video.
Test your knowledge of simple operators!
Learn how to group objects into Arrays, and also how to access them in Swift.
First we'll look at some pre-written Objective-C code that deals with arrays. Then we'll show how to write that same code in Swift, as well as going over how some enhanced Swift Array features work.
Here we'll discuss Dictionaries, which are similar to Arrays. We'll show how to create, edit, iterate and delete key-value pairs in a Swift Dictionary.
Let's take a quick look at some Dictionary related Objective-C code, and explain some of the differences between OC and Swift.
Here we'll convert our OC code to Swift, and show off how to use Subscripting syntax to access and modify dictionaries with ease.
Test your newfound knowledge of Swift Dictionaries. This quiz will test you on the definition as well as the syntax of Dictionary creation in Swift.
Control flow logic is important for any program to work. Things like if statements, switch statements, for loops and while loops are things we'll discuss in this video.
Once again, for our Objective-C developers, we look at some OC code and describe some of the differences between OC and Swift in terms of control flow statements.
Here we'll dive into Swift control flow code where we'll look at nested if statements and multiple comparative conditions to control the flow of our program.
Let's continue experimenting with Swift control flow code. Here we'll look at switch statement fallthroughs, for loops and do while loop examples. By the end of this video we should have a solid foundation in understanding how to control the flow of logic in our code.
Think you've mastered control flow in Swift? Take the quiz!
Functions are the meat and potatoes of our programs. In this video, we'll describe how to work with Functions in the context of Swift.
In this video, we'll go through some Functions written in Objective-C, that we'll later convert over to Swift.
Now we'll write the Swift code that mimics the Objective-C code from our previous video. We'll also look at some additional functionality that Swift offers us in the context of Swift functions.
Enumerations group multiple values into a Type. Here we'll go over how enumerations are created and used in Swift, including subjects like Raw Values and Auto-Enumeration.
Objective-C enumerators work much differently than Swift does. Let's go over some Objective-C code dealing with enumerations, then we'll continue on and convert that same code to Swift.
Enumerators in Swift are easy to use, but are a bit different from Objective-C. We'll go over some of those differences, as well as new features that have been included in Swift for enumerations like tuples and dot syntax value changes.
Classes are the blueprints of our program objects. This video describes how these classes work in Swift, as well as the differences between reference types, and value types.
This video showcases some pre-written objective-c code that deals with Classes, and how Classes work in Swift by comparison.
Next we'll hop into Swift and mimic the Objective-C code we went over in the last video. We'll talk about things like custom initializers, getters and setters, and how to reference classes from other files in your Swift project.
Structures are similar to Classes but are a bit simpler and trimmed down. This video will explain some of the differences between the two.
In this video we'll go through some Objective-C code so we can describe some of the differences between Objective-C and Swift in terms of Structures.
Here we'll discuss how to use structures in Swift, including showcasing a feature called Memberwise Initializers. We'll also talk a bit more about the difference between reference types and value types.
In this lecture we'll discuss Swift properties including Stored Properties, Lazy Stored Properties, Computed Properties and something called Property Observers.
Let's dive into some Swift code in XCode and experiment with the different types of properties that we just learned about. Lazy variables, custom initializers, and property observers are just some of the things we'll play with in this video.
Test your knowledge of Swift Properties!
Methods are functions that are associated with Swfit classes, structures or enumerations. In this video we'll talk about methods, both on the Type level and on the Instance level.
Here we'll go through some Objective-C code dealing with methods to show some of the differences between Swift and Objective-C when it comes to methods.
Let's dive into XCode and write some Swift code that mimics and extends some of the behaviors that we went over in the previous video. We'll talk about type properties and methods, as well as instance properties and methods and how differently they work. We'll also learn how to create a separate class file that will house our 'Animal' class.
Test your knowledge of Swift Methods!
Before we start building apps for the Apple Watch, let's take a deeper look into what hardware and sensors make up the watch, and what hardware we'll have access to.
Learn the guidelines that Apple suggests when building Apple Watch apps.
Here you'll learn about a tool you can use to view your watch apps in a realistic rendition of various Apple Watch styles!
This video will quickly get us started with XCode, Apple Watch, and setting up a basic interface for our first app!
In the first part of our series that shows how to develop a dice roller for your Apple Watch, we'll design the app, and start setting up the interface and connecting the interface to code.
In the second part of our dice roller app series, we build out our dice class.
Here we'll finish up our dice roller by testing our class, then connecting up the buttons to code!
Let's look at the completed version of our next application that we're going to build, a dog breed reference application!
We'll begin by setting up our project for What's that Dog. Tables, row classes, image management and interface layout are just a few of the things we'll go over in this lecture.
In this video we'll complete the interface layout that we want for our two interfaces.
We'll start punching in some code for our interface controllers, and going through the process of how to load a table with a set of dog breed information.
It's time to connect all of our interface elements to code. We'll write some functions that will allow the user of the app to navigate from one screen to another, and we'll go over how to send relevant information when this navigation happens.
We're almost done! We just need to add the rest of our image assets, fix up some minor layout problems, and check our data. Congrats on completing you third Apple Watch app!
More apps on the way!
Nathan is an IT professional of over 20 years.
In addition to IT work, he's also been a hobbyist developer using many different languages and platforms for many years. Currently, he's employed as a Software Engineer developing business-critical applications for iOS mobile devices and Windows.
His goal is to bring his knowledge to Udemy's student base and hopefully help those that are interested in doing the things he does.