Our iOS Bootcamp teaches the tools needed to develop iPhone and iPad applications for iOS7. Along our journey, we will learn the syntax of Objective-C, the language used to develop for iOS, as well as important design patterns and best practices. By the end of the course, you should be able to understand and recreate many of the features seen on popular iOS applications and extend that knowledge to making apps of your own.
We believe students learn by building. That's why we have you build 14 apps during the course, with the final app being a full featured dating app: A Tinder Clone!
Topics Covered:
Reviews
"I must say that so far, this course is awesome. Having the challenging assignments, daily discussions and feedback from the instructors, has been the missing piece that I have been looking for. I have read a handful of books, watched hours of video & typed in a bunch of tutorials, and finally, having to work through tough assignments and applying what I have been learning, it is all starting to click - Finally!" - Mark S.
“Code Coalition's discussion board is one of the best resources for a beginning iOS developer. So much help being offered” - Omar S.
“I've just completed the iOS101 course, which I thought was a great intro to the XCode environment... I feel it's been well worth the investment. ” - Herdy H.
"Wow, @CodeCoalition! Moving quickly! Week 2 is so different than week 1...and I like it :) Thnx for the challenge" - Melissa B.
“Just discovered @CodeCoalition! An excellent resource for anyone who wants to make their first iPhone app.” -Novall K.
“Can't reiterate it enough how this course is helping me with my iOS dev skills. I think using protocols and delegation is finally becoming second nature. Fingers crossed :-)” -Alex P.
“I am really loving the class. I have taken classes at Code School & Treehouse and both were missing a key element. The ability to ask questions as you complete a section and get an answer. “ -Lisa A.
“Your training is the best out there so far. I wish I had the time away from regular job to follow along.” -Christian S.
“Im loving this.. I have been through at least 5 books, and many online deals. Yours is super so far. Finally, i can get from start to finish on a lesson without wondering why on "Everything" thank youCant wait to do more.. “ -Kevin R.
Why take this course and how much time does it take to complete?
iOS development, and software development as a whole, is a booming career. The demand for new developers at all levels far outweighs the supply. Barrier to entry is not as high as one would think - though passion and hard work are necessary, a degree in computer science or any other technical field is not required.
We aim to take you from complete beginner to junior developer in three months. The apps you create in this course can be used on your portfolio so you have something to show when you apply for jobs.
Course Outline:
Eliot regularly teaches iOS development classes and workshops at General Assembly and guest lectures for companies and development boot camps around NYC. He also taught the inaugural class for Coalition for Queens which focused on increasing diversity in iOS development. He also coaches students in a one-on-one environment with a focus on transitioning to full time development. Eliot cofounded and organizes the iOS Office Hours meetup NYC.
In his free time he works as a contractor for startups focusing on agile development.
Find me on twitter @EliotArntz - I check my direct messages quite frequently.
|
Introduction (03:58)
|
|
Opening XCode (06:07)
|
|
Label Use (07:04)
|
|
Buttons (09:54)
|
|
Colors (04:58)
|
|
UITextField (06:12)
|
|
UINavigationController
 (07:00) |
|
Resources
|
|
What is A Variable? (06:43)
|
|
Intro to Commenting (03:05)
|
|
Operations on Variables (05:44)
|
|
Logging into the Console (03:51)
|
|
Valid Variable Names (04:11)
|
|
Tokens (05:14)
|
|
Converting Units Part 1 (06:39)
|
|
Converting Units Part 2 (06:21)
|
|
Age of Laika
|
|
Age of Laika Part 1 (05:14)
|
|
Age of Laika Part 2 (03:34)
|
|
If Statements (05:32)
|
|
BOOLS (03:03)
|
|
If Statements Cont'd (04:33)
|
|
Age of Laika Control Flow (05:29)
|
|
For Loops (04:00)
|
|
For Loops Part 2 (04:47)
|
|
99 Sodas (02:53)
|
|
Create A New Project (02:07)
|
|
What are Classes and Objects (03:15)
|
|
Make Your Own Class (03:12)
|
|
Header File (04:43)
|
|
Implementation File (02:43)
|
|
Properties (07:47)
|
|
Instantiating an Object (01:05)
|
|
Import (03:56)
|
|
Instantiating an Object Cont'd (03:59)
|
|
Setting Properties (09:56)
|
|
Methods (03:03)
|
|
Implementing our Methods (04:41)
|
|
Methods with Arguements (06:13)
|
|
Self Properties (05:48)
|
|
Self Methods (05:33)
|
|
Methods with Multiple Arguments (06:11)
|
|
Methods with Return Values (06:05)
|
|
Review (weekly recap) (07:06)
|
|
The Challenge
|
|
Methods Solution (08:26)
|
|
ADD SOME FLARE (UI ELEMENTS) (11:35)
|
|
Multiple Dogs
(10:47) |
|
NSMutableArray (02:07)
|
|
Documentation (02:25)
|
|
Multiple Dogs Continued (09:22)
|
|
EC: Animation (strictly for Extra Credit) (05:36)
|
|
The Challenge
|
|
Recuring Dog Pictures (03:13)
|
|
Inheritance (02:30)
|
|
Subclassing MBFDog (07:39)
|
|
Implementing a Superclass Method (02:17)
|
|
Super (01:27)
|
|
The Difference Between Objects and Primitives (03:43)
|
|
NSString (04:14)
|
|
Iterating through an Array (07:43)
|
|
What's Really Going On Properties (07:00)
|
|
NSArray Initializer and Embedded Array (05:38)
|
|
CGPoint (02:20)
|
|
Embedded If Statements (02:46)
|
|
Buttons and AlertViews (05:30)
|
|
Property of a Custom Class (02:46)
|
|
Introduction to nil (video) (02:33)
|
|
Pirate Assignment
|
|
Pirate Game Introduction
(13:17) |
|
Pirate Storyboard Setup (15:46)
|
|
Hooking up the View (05:04)
|
|
Creating our tile object (03:26)
|
|
Factory Object (10:20)
|
|
Factory Explained (04:04)
|
|
Setting up the Initial Tile (08:05)
|
|
Hiding our Buttons Dynamically (11:49)
|
|
Navigating Between Tiles (04:59)
|
|
Add a Story and Images (13:12)
|
|
Review (week2 wrap) (09:48)
|
|
You did it!
|
|
Weapon and Armor Class (02:17)
|
|
Creating a Character Class (03:24)
|
|
Create a Character (05:56)
|
|
Adding a Character to the Application (04:50)
|
|
Updating the Tile Model (11:00)
|
|
Implementing our Action Changes (06:03)
|
|
Finishing our Action Changes (03:23)
|
|
Create a Boss (02:30)
|
|
Implementing our Boss (02:09)
|
|
Alerting the User (04:01)
|
|
Clean up and a Reset Button (03:20)
|
|
Pirate Assignment Solution
|
|
Terminal (06:10)
|
|
Git Part 1 (09:53)
|
|
Git Part 2 (04:13)
|
|
MVC Overview (03:48)
|
|
Communication between the View Controller and Model/Views (03:09)
|
|
Communication from the View and Model to the View Controller (06:06)
|
|
Practice Using UITableView (03:38)
|
|
New Project (08:39)
|
|
A Quick Look at our Data Source (05:31)
|
|
NsIndexPath (02:44)
|
|
NSIndexPath Cont'd (03:30)
|
|
Having our TableView display our Model (06:33)
|
|
Model (02:44)
|
|
NSDictionary
(05:45) |
|
Utilizing our new Model
(04:30) |
|
NSNumber (03:12)
|
|
#define (02:03)
|
|
Literals Review (03:39)
|
|
Class Methods (02:30)
|
|
Section 3 Review (11:22)
|
|
The Challenge
|
|
UITableViewController Solution (12:09)
|
|
Making a SpaceObject Class
(02:06) |
|
Literals Cont'd (01:15)
|
|
Custom Initializers (15:46)
|
|
Lets Create and Use Space Objects
(10:14) |
|
The Challenge: User Data Model
|
|
Solution Part 1 (13:38)
|
|
Solution Part 2 (05:41)
|
|
UINavigationController (04:30)
|
|
Push Segue (02:23)
|
|
Setting up our Second View Controller (04:34)
|
|
UIScrollView - A Closer Look (02:28)
|
|
Setting up our UIScrollView (03:22)
|
|
Zooming (03:50)
|
|
Setting our ViewController as a Delegate (07:35)
|
|
The Challenge
|
|
UIScrollView Solution (07:42)
|
|
Passing Data Forward (03:02)
|
|
id and introspection (02:08)
|
|
Implementing Introspection and Passing the Data (10:48)
|
|
Passing information to Proxy Properties instead of Outlets (04:47)
|
|
The Challenge
|
|
Passing Information to another ViewController Solution (09:23)
|
|
Adding another UITableView Part 1 (05:34)
|
|
Adding Another UITable Part 2 (10:08)
|
|
Writing the Logic behind our Space Data Table View Controller (10:21)
|
|
Adding a Method from our UITableViewDelegate (04:48)
|
|
Performing the Segue (07:43)
|
|
The Challenge
|
|
UITableView Solution (08:56)
|
|
Review (07:55)
|
|
Chance of us Discovering a New Planet (06:55)
|
|
Designing our New View Controller (12:16)
|
|
One more Segue! (03:56)
|
|
Protocols in Objective-C (11:28)
|
|
Our Own Protocol Part 1 (05:50)
|
|
Our Own Protocol Part 2 (04:01)
|
|
Our Own Protocol Part 3 (02:52)
|
|
Our Own Protocol Part 4 (03:25)
|
|
Our Own Protocol Part 5 (04:07)
|
|
Reload Data (04:18)
|
|
Loose Ends (03:17)
|
|
Solution - No More Mercury (05:12)
|
|
Lazy Instantiation (06:44)
|
|
The Challenge
|
|
Protocols and Delegation Solution (06:45)
|
|
Protocols and Delegation Extra Credit (04:43)
|
|
Persistence Overview (02:15)
|
|
NSUserDefaults (03:45)
|
|
Getting our Space Objects into Tip Top Property List Shape (06:32)
|
|
Back to our NSUserDefaults (07:51)
|
|
Retrieving our Data (06:00)
|
|
Deleting some Cells from out UITableView (08:05)
|
|
The Challenge
|
|
NSUser Defaults, Segues and Protocols Solution Part 1 (13:45)
|
|
NSUser Defaults, Segues and Protocols Solution Part 2 (03:57)
|
|
NSUser Defaults, Segues and Protocols Solution Part 3 (07:54)
|
|
NSUser Defaults, Segues and Protocols Solution Part 4 (06:37)
|
|
NSUser Defaults, Segues and Protocols Solution Part 5 (05:34)
|
|
NSUser Defaults, Segues and Protocols Solution Part 6 (02:45)
|
|
Review (06:56)
|
|
.PCH File (03:01)
|
|
TextView and the Keyboard (05:17)
|
|
NSDate, Datepicker, NSDataFormatter and TimeInterval (06:31)
|
|
Insert and Remove Objects from a NSMutableArray (03:40)
|
|
Overdue Task List Assignment
|
|
Setting up the Storyboard Part 1 (05:52)
|
|
Setting up the Storyboard Part 2 (06:03)
|
|
IBOutlets (06:43)
|
|
Setup our #defines (02:25)
|
|
Creating a Task Model (03:49)
|
|
Implement the Custom Initializers (04:01)
|
|
Protocol for the Cancel and Add Task Buttons (03:42)
|
|
Call the Delegate Methods in the Cancel and AddTask Actions (03:08)
|
|
An Array to hold the Tasks (03:10)
|
|
Implementing the Delegate Methods and Saving the Task (10:29)
|
|
Segue to the AddTaskViewController (04:53)
|
|
Access NSUserDefaults to Setup the taskObjects Array (04:00)
|
|
Setup the ViewController's TableViewDataSource (09:42)
|
|
Color Coding the UiTableViewCells (05:31)
|
|
Completing a Task (09:57)
|
|
Delete a Task (05:13)
|
|
Displaying Information in the DetailViewController (06:15)
|
|
Reorder Tasks (05:51)
|
|
Persisting the Reorder (04:04)
|
|
Setting up the EditViewController (05:32)
|
|
Saving the EditViewController Changes with a Delegate (02:21)
|
|
Implementing the EditViewController Delegate (07:12)
|
|
Implementing the DetailViewController Delegate (02:51)
|
|
Make the Keyboards Go Away! (05:51)
|
|
Overdue Task List Solution
|
|
Subviews (04:42)
|
|
Difference between a View's Frame and Bounds (02:21)
|
|
A Deeper Look into a View's Frame and Bounds Part 1 (08:37)
|
|
A Deeper Look into a View's Frame and Bounds Part 2 (04:13)
|
|
Adding a UIView Programmatically (07:12)
|
|
Adding UIButton Programmatically (04:12)
|
|
Target Action (07:23)
|
|
The Challenge
|
|
Custom Views Solution (08:59)
|
|
Explore Autolayout (05:23)
|
|
Demo Autolayouts Part 1 (11:42)
|
|
Demo Autolayouts Part 2 (05:32)
|
|
View Controllers Lifecycle (03:27)
|
|
Custom Views (06:14)
|
|
Drawing with UIBezierPath Part 1 (08:31)
|
|
Drawing with UIBezierPath Part 2 (05:40)
|
|
The Challenge
|
|
UIBezierPath Solution (06:31)
|
|
Switch to an iPad Application (08:41)
|
|
More UIBezierPath
(04:42) |
|
Creating our Path (07:46)
|
|
Create a PathView Class (03:12)
|
|
How Storyboard Files are Saved (04:49)
|
|
Talk about Code Snippets (04:45)
|
|
Finishing our Mountain Path (02:03)
|
|
Gesture Recognizers (10:24)
|
|
Pan Gesture Recognizers (03:10)
|
|
Detect a UIBezierPath Hit (07:15)
|
|
NSTIMER (03:13)
|
|
Adding a Score (07:46)
|
|
Finishing Touches on our Maze (08:34)
|
|
Memory Management Detour (03:41)
|
|
Object Ownership Strong and Weak (04:43)
|
|
Retain Cycle they are Bad (04:30)
|
|
Beginning a New Journey (03:13)
|
|
Starting our New Application and the App Delegate (07:39)
|
|
Adding a Storyboard and a UITableViewController (08:38)
|
|
Core Data an Initial Light Dusting (03:11)
|
|
Updating our xdatamodel (07:32)
|
|
Adding a New Album with UIAlertView (05:23)
|
|
UIAlertViewDelegate (06:04)
|
|
It;s Alive! Creating our First NSManagedObjectSubclass (11:50)
|
|
Nsmanage ObjectSubclass a Quick Review (03:29)
|
|
Finally Creating an Album (07:09)
|
|
Querying our Database for Objects (10:37)
|
|
Review Accessing Objects from our Database (02:46)
|
|
A Quick Refactor (08:25)
|
|
UICollectionViewController (10:42)
|
|
Getting a Photo on those Slides
(10:04) |
|
UIImagePickerController (07:28)
|
|
UIImagePickerController Delegate (05:31)
|
|
Grabbing our Photo from UIImagePickerController (05:13)
|
|
Adjust our Core Data Model (07:20)
|
|
Filling out our TWPIctureDataTransformer (06:59)
|
|
Creating and Storing our Photos (06:53)
|
|
Implementing, Creating, and Storing the Photos (02:25)
|
|
Prepare the Segue Practice (05:00)
|
|
Querying the Photos and Debugging (08:01)
|
|
Adding a Photo DetailViewController (06:05)
|
|
Deleting a Photo from Core Data (08:51)
|
|
Fixing the Bug (06:17)
|
|
Adding a CollectionViewController for the Filters (05:43)
|
|
Creating Filters (02:34)
|
|
CollectionView DataSource Methods (07:35)
|
|
Adding our Filters (12:20)
|
|
Through our Filters (09:14)
|
|
Saving our Filters (06:12)
|
|
Why is our App Slow (04:53)
|
|
GCD and Threading Overview (05:03)
|
|
Blocks (04:52)
|
|
Creating a Block and Implementing it (04:58)
|
|
GCD Example (07:21)
|
|
Fixing our Bug (03:49)
|
|
Install Ruby and Ruby Gems (08:31)
|
|
What is CocoaPods and Installation (02:27)
|
|
Sign Up for Parse (04:21)
|
|
What is Parse and Why use it (06:31)
|
|
Installing Parse (05:51)
|
|
Installing Parse The Hard Way (04:38)
|
|
Is Parse Working (05:01)
|
|
Testing Parse Storyboard Setup (04:25)
|
|
Creating PFObjects (03:43)
|
|
Saving PFObjects (03:38)
|
|
Querying for the PFObjects (06:11)
|
|
Matchedup
(07:46) |
|
Setting up Parse (04:21)
|
|
Sign up and Setting up Facebook (04:00)
|
|
Integrating Facebook (06:58)
|
|
Installing Facebook the Hard Way (02:47)
|
|
Login Functionality (10:18)
|
|
PFUser (02:22)
|
|
Saving User Information (11:36)
|
|
A Deeper Look in Facebook's API (02:07)
|
|
Global Constants (08:34)
|
|
Implementing Our Constants (02:37)
|
|
Prep to Save a Photo Creating Constants and a URL (07:14)
|
|
Saving the Image with a PFFile (07:26)
|
|
Hitting the URL (07:22)
|
|
Implementing NSURLConnection Delegates (03:20)
|
|
What if the User is Already Logged in? (03:57)
|
|
Adding a Picture to the ProfileViewController (07:40)
|
|
Wireframes
(01:01) |
|
Storyboard Refactor (01:28)
|
|
Add a HomeViewController (10:09)
|
|
Add a SettingsViewController (08:23)
|
|
Add a EditProfileViewController (06:52)
|
|
Add a ProfileViewController (06:33)
|
|
Refactor Login View Controller (07:29)
|
|
Setting up the HomeViewController (07:57)
|
|
Downloading the Home Photo (06:50)
|
|
Updating the Home View's Information (03:06)
|
|
Loading the Next Photo (03:40)
|
|
Save a Like (08:30)
|
|
Save a Dislike (03:20)
|
|
Check for Likes (03:25)
|
|
Check for Dislikes (02:59)
|
|
Implement our Helper Methods (02:07)
|
|
Doing a Initial Query for Likes (11:59)
|
|
Creating Global Constants for the HomeViewController (05:35)
|
|
Implementing Constants in the HomeViewController (07:46)
|
|
Creating a Test Users (12:42)
|
|
Implementing the ProfileViewController (07:33)
|
|
Global Constants for the Settings Page (02:51)
|
|
Setting Initial Values and Preparing the Slider and Switches (05:20)
|
|
Sliders and Switch Changes (05:49)
|
|
Loading the EditProfileViewController (03:15)
|
|
Saving the TagLine (02:00)
|
|
Logging Out (02:36)
|
|
Storyboard Setup Match (06:52)
|
|
Storyboard Setup Matches (03:13)
|
|
Storyboard Setup Chat (06:25)
|
|
Check for Users Likes (05:53)
|
|
Create a ChatRoom (10:33)
|
|
Prepping the MatchViewController (02:51)
|
|
Implementing the MatchViewController (05:34)
|
|
Adding a Delegate to the MatchViewController (05:40)
|
|
Finding Available Chats (07:30)
|
|
Presenting Available Chats (08:19)
|
|
Adding a Picture to the Chat List (06:39)
|
|
Selecting a ChatRoom (03:27)
|
|
Prepare the ChatViewController (03:11)
|
|
Getting Started Implementing Chats (05:29)
|
|
didSendText (05:29)
|
|
messageTypeForRowAtIndexPath (02:47)
|
|
bubbleImageViewWithType (02:29)
|
|
Additional Methods (03:11)
|
|
Optional Methods (02:03)
|
|
Required (03:32)
|
|
Check for Chats (05:29)
|
|
Refreshing our Chat (03:36)
|
|
Testing Chats (05:02)
|
|
Setup Defaults Settings (07:37)
|
|
Allow Photo Helper Method (08:27)
|
|
Implement the Allow Photo (04:28)
|
|
Constants for ChatRoom and Chat (04:35)
|
|
Implementing Constants (05:56)
|
|
Asset Library
(03:01) |
|
Setting a Global Nav Bar (03:03)
|
|
Assets Login ViewController (03:37)
|
|
Asset Home ViewController (13:50)
|
|
Assets Profile ViewController (08:39)
|
|
Finishing up the Profile ViewController (07:49)
|
|
Assets Matches ViewController (01:23)
|
|
Update the ChatViewController (02:29)
|
|
Assets Setting ViewController (02:32)
|
|
EditProfile View Controller (07:32)
|
|
MatchViewController (04:46)
|
|
Create a Transition Class (03:34)
|
|
Conform and Implement UIViewControllerTransitioningDelegate (09:14)
|
|
Getting Started with MixPanel (02:57)
|
|
Implement MixPanel (03:59)
|
|
Using MixPanel (03:43)
|
|
You did it!
|
|
MVC Review Part 1 (07:56)
|
|
MVC Review Part 2 (07:19)
|
|
MVC Review Part 3 (11:34)
|
|
MVC Review Part 4 (04:47)
|
|
Introduction Libraries and Learning Goals (05:56)
|
|
Dependencies and Libraries (07:52)
|
|
Storyboard Setup (07:52)
|
|
Model Adding Entities (08:41)
|
|
Model Adding Relationships (02:22)
|
|
Adding a PrimaryAttributeKey (05:39)
|
|
Subclassing MMRecord and keyPathForResponseObject (04:38)
|
|
Subclassing AFHTTPSessionManager (07:32)
|
|
foursquare ClientID and ClientSecret (03:33)
|
|
Imports and MagicalRecord Setup (04:43)
|
|
Customizing TCFourSquareSesssionManager (06:05)
|
|
Making our First Request (07:33)
|
|
Displaying the Information (05:02)
|
|
Current Location (08:39)
|
|
Venue Setup (03:02)
|
|
Setting up the Map (06:54)
|
|
Finishing up our MapViewController (04:04)
|
|
Updating the MapViewController (02:00)
|
|
Setting up the Directions ViewController (05:14)
|
|
Location Manager a Quick Review (07:32)
|
|
Getting Directions (05:56)
|
|
Using our Directions Method (06:36)
|
|
Getting the Route (05:43)
|
|
Adding a Latitude and Longitude Offset (02:59)
|
|
Drawing our Overlay (05:23)
|
|
Setup the DirectionsListViewController (04:03)
|
|
Segue To The DirectionsListViewController (04:44)
|
|
Setup the List of Directions (07:17)
|
|
Adding a TableViewHeader (03:12)
|
|
Adding Map Snapshots (09:37)
|
|
Installing a Facebook style Menu with MMDrawerController (03:36)
|
|
Adding a MenuViewController to the Storyboard (04:45)
|
|
Update the App Delegate (09:52)
|
|
Setting Drawer Attributes (04:56)
|
|
Adding Animations to our Menu (04:06)
|
|
Adding a Menu Button
(05:24) |
|
Setting up the MenuViewController (03:08)
|
|
Adding our ListViewController to the Menu (08:57)
|
|
Selecting our Menu Item (02:09)
|
|
Adding some More ViewControllers (07:56)
|
|
Adding our new ViewControllers to the Menu ViewController (05:22)
|
|
Adding Menu Buttons to the Favorite and Add Venue ViewControllers (04:07)
|
|
Adding Favoriting (05:31)
|
|
Save using MagicalRecord (02:11)
|
|
Displaying our Favorite Venues with Magical Record (07:29)
|
|
Creating our a custom Venue with Magical Record (06:18)
|
