Our iOS Bootcamp teaches the tools needed to develop iPhone and iPad applications for iOS 8. Along our journey, we will learn the syntax of Swift, 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 with multiple users, direct chat, and complete profiles.
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.
"This course is by far the most elaborate and best taught iOS course I have seen online yet. It's good structured and covers a lot of topics in-depth." - Christoph Zamaitat
“Bitfountain's discussion board is one of the best resources for a beginning iOS developer. So much help being offered” - Omar S.
"Great course for total beginners, but also a lot of tricks and tips for those with experience. Also good seeing how others code and tackle problems. A great learning tool what ever your skill level." - Mazza1111
“I've just completed the iOS course, which I thought was a great intro to the XCode environment... I feel it's been well worth the investment. ” - Herdy H.
"I am about a quarter of the way through this course and have no previous programming experience. I have found this course to be well presented and structured with everything explained clearly. This is a difficult topic and you have to work hard understanding the concepts if you are new to it, but it is easy to go back over an area to pick up anything you might have missed first time round. The guys are constantly improving it and adding to it and seem committed to getting it 100% right. Recommend it....but be prepared to work hard!!" - Tony McDonald
“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 you. Cant 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.
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.
|
Course Introduction (06:01)
|
|
Course Resources (03:50)
|
|
Downloading Xcode (02:42)
|
|
Opening XCode and Creating our First Project (08:58)
|
|
A Brief Tour of Xcode (10:26)
|
|
Exploring Storyboard (09:14)
|
|
Setting up a New View (06:02)
|
|
Adding a NavigationController (05:56)
|
|
Adding a Title and Another Image (05:52)
|
|
Adding TextFields (04:30)
|
|
Adding a Button and a Label (03:13)
|
|
Hooking up our View Objects (14:12)
|
|
Debugging Connection Errors (06:53)
|
|
Unhiding our Label (05:26)
|
|
Changing a Label's Text in Code (05:01)
|
|
Changing a TextField's Text in Code (02:36)
|
|
Moving our Label and Closing the Keyboard (05:39)
|
|
Multi Line Label (02:57)
|
|
Changing a Label's Color in Code (03:22)
|
|
Let's Update our Button (04:27)
|
|
Terminal (10:07)
|
|
Creating a Project on Github (02:26)
|
|
Saving our Project to Github (07:43)
|
|
Adding an Additional Commit (03:17)
|
|
Downloading and Opening a Project from Github (02:07)
|
|
Challenge 1: Practicing with the Storyboard (02:25)
|
|
Challenge 1: Practicing with the Storyboard Solution (05:59)
|
|
Challenge 2: Save your Changes to Github (01:48)
|
|
Challenge 2: Save your Changes to Github Solution (02:50)
|
|
What is a Variable? (06:24)
|
|
Type Annotations (04:42)
|
|
Intro to Commenting (05:44)
|
|
Operations on Variables Ints (03:09)
|
|
Operations on Variables Floats (05:16)
|
|
Valid Variable Names (03:05)
|
|
Typealias (03:50)
|
|
Numeric Literals (02:46)
|
|
Strings and Characters (05:29)
|
|
String Interpolation (02:54)
|
|
Optionals Int (05:32)
|
|
String to Double (05:30)
|
|
Shorthand (02:01)
|
|
Constants (03:44)
|
|
Shoe Size Converter (12:24)
|
|
Refactor Shoe Converter (03:23)
|
|
Adding Women's Shoes (07:04)
|
|
Age of Laika (01:14)
|
|
Age of Laika: Solution Part 1 (06:40)
|
|
Age of Laika: Solution Part 2 (03:08)
|
|
If Statements (07:51)
|
|
Bools (03:35)
|
|
If Statements Continued (05:44)
|
|
Numeric Type Conversion (03:10)
|
|
Age of Laika: Control Flow Challenge (02:46)
|
|
Age of Laika: Control Flow Solution (06:51)
|
|
For Loops (06:20)
|
|
Limitations of For Loops (03:27)
|
|
99 Sodas Challenge (01:04)
|
|
99 Sodas Challenge Solution (03:14)
|
|
Intro to Object Oriented Programming (03:27)
|
|
What are Structs and Instances? (03:39)
|
|
Create a New Project and Storyboard Setup (10:05)
|
|
Make Your Own Struct (02:51)
|
|
Adding Properties to the Tiger (05:41)
|
|
Instantiating our First Struct (05:24)
|
|
Using the Tiger Instance (03:42)
|
|
Multiple Tigers (05:57)
|
|
Introduction to Arrays (02:20)
|
|
Create an Array (04:42)
|
|
Two Cool Properties of Arrays (02:26)
|
|
Indexing into an Array and Iterating Over an Array (04:21)
|
|
Ranges and For in Loops (04:17)
|
|
For in Enumerate Loop (03:53)
|
|
Mutating an Array (10:36)
|
|
Generating a Random Number (04:15)
|
|
Adding Tigers to an Array (06:20)
|
|
Show a Random Tiger (03:13)
|
|
Animating our Tigers (09:09)
|
|
While Loops (04:57)
|
|
Recurring Tiger Bug (07:37)
|
|
Our First Function (04:37)
|
|
Our First Parameter (04:28)
|
|
Multiple Parameters (04:34)
|
|
Return Values (06:23)
|
|
Another Return Value and Other Function Calls (05:46)
|
|
Looking at the Current Functions (03:43)
|
|
The Tiger can Chuff (03:07)
|
|
Chuff a Number of Times and Self (13:09)
|
|
Self Continued (03:23)
|
|
Chuff a Number of Times with Control Flow (05:53)
|
|
Update Tigers Age Function (05:57)
|
|
Adding a Random Fact Function (08:56)
|
|
Switch Statement (04:07)
|
|
99 Red Balloons Struct Challenge (02:19)
|
|
99 Red Balloons Storyboard Setup Solution (05:48)
|
|
99 Red Balloons Struct Solution (02:39)
|
|
99 Red Balloons Create Balloons Function Solution (07:11)
|
|
99 Red Balloons Update UI Solution (04:49)
|
|
Classes and Structs (03:03)
|
|
Creating a Lion (07:33)
|
|
Create a Lion Array (02:36)
|
|
Introduction to Tuples (03:18)
|
|
Switch Statement with a Tuple (03:04)
|
|
Update Current Animal (05:28)
|
|
Displaying both Lions and Tigers (07:09)
|
|
Lion Roar Function (01:13)
|
|
Accessing Properties in a Function (02:13)
|
|
Lion Random Fact Function (03:17)
|
|
Subclass the Lion Class (04:41)
|
|
Override Function in LionCub Class (03:01)
|
|
Super Keyword (02:32)
|
|
Additional Function and a Female Lion Cub (07:36)
|
|
Displaying Lion Cubs (05:35)
|
|
SlotMachine: Introduction (03:13)
|
|
SlotMachine: Starting our New App (04:31)
|
|
SlotMachine: Setup ContainerViews (20:27)
|
|
SlotMachine: Finishing Setup ContainerViews (10:15)
|
|
SlotMachine: setupFirstContainer (06:10)
|
|
SlotMachine: setupSecondContainer (11:10)
|
|
SlotMachine: setupThirdContainer (07:12)
|
|
SlotMachine: Some more Labels in the ThirdContainer (06:53)
|
|
SlotMachine: Finish adding Labels to the ThirdContainer (07:09)
|
|
SlotMachine: Start Setup FourthContainer (16:06)
|
|
SlotMachine: Another Button in the fourth Container (07:20)
|
|
SlotMachine: Finishing the fourth Container (07:27)
|
|
SlotMachine: Adding a Slot Struct (02:45)
|
|
SlotMachine: Adding Assets (02:40)
|
|
SlotMachine: Factory Class (14:52)
|
|
SlotMachine: Create Slot (15:40)
|
|
SlotMachine: Implementing Create Slot (01:23)
|
|
SlotMachine: Slots Array (02:05)
|
|
SlotMachine: Showing Slots (03:15)
|
|
SlotMachine: Remove old ImageViews (05:24)
|
|
SlotMachine: hardReset (04:02)
|
|
SlotMachine: updateMainView (01:26)
|
|
SlotMachine: showAlertWithText (05:31)
|
|
SlotMachine: betOneButtonPressed (03:45)
|
|
SlotMachine: betMaxButtonPressed (03:54)
|
|
SlotMachine: Reordering Slots into Rows (07:01)
|
|
SlotMachine: computeWinnings (03:03)
|
|
SlotMachine: Check for Flush (05:59)
|
|
SlotMachine: Check for Three in a Row (04:20)
|
|
SlotMachine: Check for Three of a Kind (03:50)
|
|
SlotMachine: Finishing Touches (04:31)
|
|
Lemonade Stand Assignment!!!
|
|
Lemonade Stand: Storyboard Solution (11:23)
|
|
Lemonade Stand: Connection's Solution (08:36)
|
|
Lemonade Stand: Supplies Solution (04:22)
|
|
Lemonade Stand: Price Solution (01:03)
|
|
Lemonade Stand: Instantiating Price and Supplies Solution (03:26)
|
|
Lemonade Stand: Instantiating Tracking Values Solution (02:38)
|
|
Lemonade Stand: updateMainView Solution (05:12)
|
|
Lemonade Stand: showAlertWithText Solution (04:53)
|
|
Lemonade Stand: Use updateMainView Solution (01:19)
|
|
Lemonade Stand: startDayButtonPressed Solution (11:00)
|
|
Lemonade Stand: purchase IceCubes and Lemons Solution (05:37)
|
|
Lemonade Stand: unpurchase IceCubes and Lemons Solution (04:47)
|
|
Lemonade Stand: Mix Functions Solution (07:31)
|
|
Lemonade Stand: Clear Mix and Purchases Solution (02:35)
|
|
Lemonade Stand: Weather Properties Solution (02:58)
|
|
Lemonade Stand: Indexing into WeatherArray Solution (02:37)
|
|
Lemonade Stand: Using the Weather Array Solution (04:03)
|
|
Lemonade Stand: Add weatherImageView Solution (02:42)
|
|
Lemonade Stand: Adding Image Assets Solution (01:35)
|
|
Lemonade Stand: Displaying Weather Solution (02:46)
|
|
Task It: Setup Options (02:05)
|
|
Task It: Add a TableView (04:30)
|
|
Task It: Add a TableViewCell (03:03)
|
|
Task It: UITableViewDataSource and UITableViewDelegate (08:24)
|
|
Task It: Updating UITableViewDataSource Delegate (02:26)
|
|
Task It: Setting up Prototype Cell (05:16)
|
|
Task It: Updating UITableViewDataSource (08:30)
|
|
Task It: Adding Labels to the TaskCell (05:19)
|
|
Task It: Adding Tasks (11:29)
|
|
Task It: TaskModel (02:18)
|
|
Task It: Implementing the TaskModel (04:21)
|
|
Task It: TaskDetailViewController (07:11)
|
|
Task It: didSelectRowAtIndexPath (03:54)
|
|
Task It: PrepareForSegue (08:05)
|
|
Task It: Updating the DetailTaskViewController (03:09)
|
|
Task It: Date Class (06:48)
|
|
Task It: Updating Dates (02:41)
|
|
Task It: NSDate to String (05:53)
|
|
Task It: Update DatePicker (01:04)
|
|
TaskIt: AddTaskViewController and Storyboard Changes (07:54)
|
|
Task It: Dismiss and Pop ViewControllers (08:58)
|
|
Task It: AddTaskViewController Setup (02:06)
|
|
Task It: Add a Task (05:39)
|
|
Task It: AddTask Segue (03:13)
|
|
Task It: ViewDidAppear (03:09)
|
|
Task It: Passing the ViewController to the TaskDetailViewController (01:19)
|
|
Task It: Pop the TaskDetailViewController (02:00)
|
|
Task It: Update Tasks (04:39)
|
|
Task It: Organize Tasks by Date (08:17)
|
|
Task It: TaskModel Completion (03:08)
|
|
Task It: Creating a BaseArray (03:34)
|
|
Task It: Updates with the Base Array (05:15)
|
|
Task It: Finish Fixing the Errors (04:51)
|
|
Task It: Adding Section Headers (02:02)
|
|
Task It: Completing Tasks (05:42)
|
|
Task It: Uncompleting Tasks (03:16)
|
|
Task It: Getting Ready for CoreData (01:25)
|
|
Task It: Setting up the CoreData Stack (10:36)
|
|
Task It: Setting up the new TaskModel (05:09)
|
|
Task It: Creating and Accessing a TaskModel (12:00)
|
|
Task It: Setting Up the FetchedResultsController (10:26)
|
|
Task It: Updating the UITableView DataSource Functions (07:38)
|
|
Task It: Updating prepareForSegue and Removing MainVC Properties (02:34)
|
|
Task It: Updating doneBarButtonItemPressed Function (03:47)
|
|
Task It: Adding Completion Sort Descriptor (04:49)
|
|
ExchangeAGram: Introduction
|
|
ExchangeAGram: Setup (05:15)
|
|
ExchangeAGram: Storyboard Updates (04:16)
|
|
ExchangeAGram: UICollectionViewDataSource (04:21)
|
|
ExchangeAGram: FeedCell (05:26)
|
|
ExchangeAGram: CameraController (10:57)
|
|
ExchangeAGram: Photo Library (06:27)
|
|
ExchangeAGram: didFinishPickingImage (04:07)
|
|
ExchangeAGram: Creating a FeedItem (02:14)
|
|
ExchangeAGram: Persisting a FeedItem (07:38)
|
|
ExchangeAGram: NSFetchRequest (06:06)
|
|
ExchangeAGram: Displaying the FeedItem (08:06)
|
|
ExchangeAGram: FilterViewController (02:54)
|
|
ExchangeAGram: didSelectItemAtIndexPath (02:52)
|
|
ExchangeAGram: Presenting the FilterViewController (03:56)
|
|
ExchangeAGram: Begin Creating a UICollectionView (08:33)
|
|
ExchangeAGram: Finishing the UICollectionView (02:34)
|
|
ExchangeAGram: FilterCell (07:26)
|
|
ExchangeAGram: Implementing our FilterCell (04:22)
|
|
ExchangeAGram: PhotoFilters (05:10)
|
|
ExchangeAGram: Properties of CIFilters (06:28)
|
|
ExchangeAGram: Composite Filters (05:32)
|
|
ExchangeAGram: Using the Filters (07:58)
|
|
ExchangeAGram: Implementing our Filters (04:09)
|
|
ExchangeAGram: Intro to GCD (08:25)
|
|
ExchangeAGram: Was that extra work in filteredImageFromImage worth it? (02:09)
|
