Developing for iOS is a valuable and in-demand skill, but if you haven’t developed in the Apple world before, it can be surprisingly different.

In this course, iOS 14: Getting Started, you’ll quickly get up and running using Xcode 12, Swift 5, and SwiftUI to build great iOS apps and tap into the latest features in iOS 14.

iOS 14 Getting Started

Course Outline

First, you’ll see the tools and learn how to create iOS apps with adaptive user interfaces that work on multiple devices.

Next, you’ll learn how to manage iOS projects and define the building blocks of your own iOS applications.

Finally, you’ll explore working with data-driven controls and understand navigation options.

When you’re finished with this course, you’ll know current best practices, iOS architecture, and the most important ideas you need to feel comfortable bringing your developer skills into the iOS and Apple developer world.

1 – Preparing to Build iOS Applications

Prepare to implement iOS apps by understanding what’s involved from a big picture standpoint.

We begin at the beginning to bring you up to speed and set the foundation for the remainder of the course.

Topics in this module include…

• What You Need for Building iOS Apps
• Creating an iOS Project with Xcode
• Exploring an iOS Project
• How to Learn iOS
• The Night Watch Scenario
• Working with Xcode Projects
• Grasping the Basics of the Xcode Development Environment
• Summary

2 - Building Single View Applications

Building single view applications is the starting point for most of us who are learning to build iOS apps because they allow us a simplified architecture that focuses on a single screen performing a single responsibility.

Topics in this module include…

• Preparing to Build Single View Apps
• Understanding the SwiftUI Framework
• Understanding Views
• Combining and Laying out Views
• Understanding the SwiftUI Layout System
• Aligning and Positioning Views
• Customizing UI Appearance
• Developing a SwiftUI Mindset
• Using Icons and Symbols
• Managing Views with Groups

3 - Creating Data-driven Lists

Just about any day in which you use an iPhone or iPad for more than a few minutes, you’ll almost certainly end up in an app that uses a List View.

It’s the most common way to show a structured, scrollable series of items, and List Views are a core competency for an iOS developer working in SwiftUI, so it’s the first complex control we dive into.

Topics in this module include…

• Preparing to Work with Lists
• Understanding Lists
• Creating a List
• Controlling a List with Data
• Using ForEach to Supply List Content
• Adding Sections and Headings

4 - Building iOS Apps with Multiple Screens

Here I cover how to create apps multiple screens and how to think about and enable navigation between them.

Topics in this module include…

• Defining Apps with Multiple Screens
• Implementing Navigation Views
• Adding Navigation to an Existing Project
• Extracting Reusable Subviews
• Creating a Tabbed Application
• Recapping Multi-view Applications

5 - Adding Behavior and Working With Data

The thing that makes an app come alive is the behavior we add, and the dynamic responses to that behavior that get reflected in the user interface.

In any application, a user interface has one critical job: to accurately represent the data of our application in what it displays on the screen.

In SwiftUI, data and behavior go hand-in-hand, and I cover how to respond to user interaction in this module.

Topics in this module include…

• Preparing to Add Basic Behavior
• Extending the Data Model
• Understanding the View Update Cycle in SwiftUI
• Adding Basic Behavior
• Connecting a Subview to a Parent View’s Data
• Using Classes as Data Models
• Sharing a Data Model through the SwiftUI Environment
• Bringing the Data Model and Behavior to the Night Watch App

6 - Putting It All Together

There’s nothing like practicing your skills in new contexts to refine them and solidify what you’ve learned.

We go into some additional controls and techniques for building apps with SwiftUI before concluding the course.

Topics in this module include…

• Applying What You’ve Learned
• Integrating the Extended Data Model
• Adding the Mark Complete Behavior
• Adding a Toolbar and Toggle Control
• Implementing Swipe and Move Actions for a List
• Resetting the List
• Showing an Alert
• Creating an Adaptive UI
• Adding and Customizing Layout Variations
• Getting Ready for the App Store

7 - Publishing to the App Store

Finishing an app and getting it out the door to your users is one of the best feelings in the world.

Beyond the emotional aspect of publishing an app though, more and more employers want to see job candidates who have published at least one app to the App Store.

So in this final module, I complete the journey by setting you up to get an app into the App Store and bolster your resume!

Topics in this module include…

• Preparing to Publish Your App
• Adding Images and App Icons
• Responding to Dark Mode
• Creating an iOS App Launch Screen
• Submitting an App for Review
• Continuing Your iOS Developer Journey

Feedback Welcome!

From the beginning my unwavering goal is to help you filter the noise and learn as efficiently as possible. My hope is that this course benefits you in your iOS development career!

I welcome feedback on this course, and on other iOS development courses you might be interested in seeing in the Pluralsight library. Happy learning!

Monetizing apps is challenging. In this course, Implementing In-App Purchases on iOS, you’ll learn to offer digital products and services directly within your app as in-app purchases.

Implementing In-App Purchases on iOS

Course Outline

First, you’ll explore how to translate business requirements into digital products and configure them in App Store Connect and Xcode.

Next, you’ll discover how to build and test a store within your app using StoreKit.

Finally, you’ll learn how to make sure purchases made within your app are authentic, and unlock content that’s been purchased by your users.

When you’re finished with this course, you’ll have the skills and knowledge needed to implement in-app purchases on iOS!

1 – Preparing to Implement In-App Purchases

Prepare to implement in-app purchases by understanding what’s involved from a big picture standpoint.

You will learn to configure digital products in App Store Connect and Xcode to kick off your in-app purchase learning adventure.

Topics in this module include…

• The Perks (And the Work) Ahead of You
• First Things First - Checking off the Prerequisites
• Matching Product Types to Business Requirements
• Setting Up Products in App Store Connect
• Setting Up an Auto-Renewable Subscription
• Configuring an Xcode Project for In-App Purchases

2 – Building In-App Purchase Functionality with StoreKit

The focus of this module is on the StoreKit APIs for working with digital products and App Store Connect.

You will learn to build and test a fully-working store view that will support in-app purchases.

Topics in this module include…

• Using StoreKit to Build In-App Purchase Functionality: A Roadmap
• Retrieving a Set of Products for Purchase from the App Store
• Displaying Products in a User Interface
• Implementing a “Buy” Button
• Preparing to Test Purchases by Setting up a Sandbox Tester Account
• Making Test Purchases
• Implementing a “Restore Purchases” Button

3 – Protecting Your Revenue by Verifying Purchase Authenticity

After all your hard work to implement in-app purchases, how awful would it be if malicious users stole the content you’ve labored to create?

In this module, you will learn to implement measures to protect revenue generated through in-app purchases by validating App Store receipts.

Receipt validation is a notoriously burdensome hassle. But it doesn’t have to be!

I will teach you how to implement server-side receipt validation from end-to-end with no third-party libraries, no complicated server setup, and no platform-specific proprietary tools.

Here’s the roadmap of topics incluced:

• Verifying Purchase Authenticity by Validating App Store Receipts
• Weighing Strategies for Receipt Validation
• Charting the Course for Server-side Receipt Validation
• Sending the Receipt from Your App to Your Server
• Writing Server-side Code to Forward the Receipt to the App Store for Validation
• Handling the Response from the App Store on Your Server
• Accounting for the Sandbox Environment on Your Server
• Handling the Response from Your Server in Your App
• The Case of the Missing Receipt: Requesting a Refresh

4 – Unlocking Purchased Content

After a user makes a valid purchase, you’ve got to unlock the content they legitimately bought!

Each product type has its own nuances for how to unlock and provide the associated content though.

What do you need to think about, and what code do you need to write to make it happen?

To find out, you will explore these topics:

• Analyzing Content-providing Logic by Product Type
• Persisting Purchased Products Securely
• Using the iOS Keychain
• Keeping Track of Consumable Product Inventory
• Managing Non-Renewing Subscriptions
• Synchronizing Purchases Across Devices
• Handling Auto-Renewable Subscriptions
• Saving Non-Consumable Transactions
• Preparing for App Store Review

Feedback Welcome!

From the beginning I set out to make the course I wish I had when I started learning to implement in-app purchases for my apps. My unwavering goal is to help you filter the noise and learn as efficiently as possible. My hope is that this course benefits you in your iOS development career!

I welcome feedback on this course, and on other iOS development courses you might be interested in seeing in the Pluralsight library. Happy learning!

Bugs are bound to happen. Getting rid of them is an essential skill if you want to keep your sanity when building apps.

In this course, you will learn a set of thinking skills to couple with the fundamental tools that Xcode provides you for finding and fixing flaws in your apps.

🐞1.5 hours 🦟To the point 🐛Engaging storyline 🐜Relevant demos

iOS Debugging Fundamentals

Course Outline

First, you will learn to approach debugging situations with a set of principles for strategic problem solving.

Next, you will discover how to configure breakpoints and inspect view hierarchies effectively.

Finally, you will explore how to interpret a backtrace, glean valuable information from the Xcode debug area and console, locate changes in your codebase and simulate conditions that happen in the wild.

When you are finished with this course, you will have the skills and knowledge to strategically and methodically reason about probable causes of defects that you experience at runtime.

1 – Debugging as Strategic Problem Solving

Debugging means a lot of things to a lot of people.

In this module, I will define the scope of debugging for you so that you’re clear on the skills you’ll walk away from this course with.

You will begin to develop a problem solving mentality and learn a useful mnemonic for R.E.P.A.I.R.-ing broken apps.

Learn how to categorize bugs into buckets for strategic resolution.

Explore some of the most common sources of bugs to complete this module.

2 – Correcting Unmet Expectations

Probabilistic thinking is the key component of a debugging mindset.

Topics in this module include…

• Pausing an App to Gather Clues With Breakpoints
• Combining Problem Solving with Xcode Tools
• Managing Your Project’s Breakpoints
• Controlling Breakpoints by Defining Trigger Conditions
• Executing Actions When Breakpoints Are Triggered
• Inspecting User Interface Issues

3 – Addressing App Crashes

When an app crashes, it’s because of a critical problem that can’t be recovered from.

In this module you will work on the following:

• Understanding Exceptional Issues
• Inspecting the Crash Scene with the Backtrace and Console Output
• Pausing before Errors and Exceptions Cause Crashes
• Avoiding Errors that Cause Crashes

4 – Alleviating Anomalies

Have you ever found yourself saying, “Something weird is going on” or “It used to work - what’s going on now??”

Have you ever experienced one of those “intermittent” bugs that seem to present themselves rarely or inconsistently and are hard to even reproduce?

Anomalous bugs can feel like they occur “out of nowhere”… but do they?

To find out, you will explore these topics:

• Reasoning About Anomalous Bugs
• Inspecting App Changes
• Simulating Real-World Conditions With Xcode

Feedback Welcome!

My unwavering goal is to help you filter the noise and learn as efficiently as possible.

I welcome feedback on this course, and on other iOS development courses you might be interested in seeing in the Pluralsight library. Happy learning!

We’ve all been there. Do a search on the topic of “saving data in iOS” and you’ll get dozens of search results mentioning at least six different frameworks and platforms, and a month’s worth of reading.

Wouldn’t it be nice to distill the possibilities down into just what you need in order to start down a path for persisting data in your app?

“iOS Data Persistence: The Big Picture” will be worth the hour of your time.

iOS Data Persistence: The Big Picture

Course Outline

During this one hour course, you will learn the reasons for saving data to help ground you as you begin to traverse the data persistence landscape.

You will discover how to use technologies like User Defaults and Property Lists, and I will guide you on how to work with Swift’s Encodable and Decodable protocols.

You will understand what you’re getting into if you choose to work with SQLite, Core Data, or Realm Database for local data persistence.

You will know how it feels to reach for a remote data storage option like CloudKit, Realm Platform, or Firebase.

Finally, you will see a clear picture of what it’s like to design a document-based application and integrate your app’s data with the iOS Files app.

When you’re finished with this course, you will have the skills and knowledge you need to make an informed decision about putting a reliable data storage plan for your iOS app into action.

1 – Establishing the Data Persistence Landscape

During the course, you will have the opportunity to experience a variety of data persistence scenarios and technologies.

You’ll get general feel for setup requirements and a taste of what it’s like to work with each solution in code.

• To start you off on the right footing, this module will establish the data persistence possibilities and focus in on the reasons for saving data so that you’re persisting with a purpose.
• You will be introduced to a player profile matrix to help you analyze your data persistence options from a number of angles.
• Finally, you will get the feel for working with the Swift Encodable and Decodable protocols.

2 – Saving Settings and Configuration

Users are picky, aren’t they? Everybody has preferences though, so it’s no wonder that you as a developer are often tasked with letting your users to customize their experience within your app.

• You will learn how to manage user preferences with the UserDefaults system that’s built in to iOS
• Next, you will explore synchronizing settings with iCloud Key-Value Store
• Finally, you will understand how to ship configuration for your app with Property Lists that are included in your application bundle

4 – Saving Objects and Object Graphs

What if you only wanted to load a subset of the data into memory instead of being locked in to an all-or-nothing situation with UserDefaults or Property Lists?

What if you needed to save a more complex data model that includes relationships?

For that, you’ll need to know about saving and sharing objects and object graphs…

Six Technologies/Frameworks will be featured in this module:

• SQLite
• Core Data
• Realm Database
• CloudKit
• Realm Platform
• Firebase

The goal is to help you answer two questions:

• “What am I getting myself into if I pick one persistence technology over another?”
• “How does it feel to work with this persistence technology in code?”

You will answer these questions by…

• Scanning the arena of persistence options and explore what sets these technologies apart from UserDefaults and Property Lists.
• Surveying the setup process to see what it takes to get up and running with each technology in the list
• Exploring the data modeling process to wrap your head around what the data structure design process is like for each technology in the list
• Getting the feel for working with data so that you understand what it’s like to create objects, update them, delete them, query and filter them, and watch for data changes so that you can update your user interface appropriately

5 – Saving Data as Documents and Files

What if you need to encapsulate chunks of content together and save it all as a packaged up file…as a single unit with a custom file extension?

For that, you need to know about saving data as documents and files.

• You will explore the use-case for building a “document-based application”
• Next you will walk through designing a document as a subclass of UIDocument
• You will learn to create and load documents from a Document Browser
• Customizing your app’s file extension is a key step that you will work through
• You will spend some time understanding how to interact with document data in code as users interact with the user interface
• Finally, you will answer the question, “How do I get my app’s files to show up in the iOS Files app?”

Feedback Welcome!

My goal is to help you filter the noise… to help you distill an overwhelming amount of information down into the big picture possibilities so that you’re on a trajectory for being able to make an informed decision about putting a reliable data storage plan for your iOS app into action.

I welcome feedback on this course, and on other iOS development courses you might be interested in seeing in the Pluralsight library. Happy learning!

At the core of developing a seamless and collaborative data sharing experience for Apple’s platforms is a thorough knowledge of CloudKit.

In this course, you’ll learn to leverage Apple’s flagship framework to achieve your app’s remote data storage and data sharing requirements.

First, you’ll learn how to configure CloudKit in your Xcode project and how to save, query, update, and delete data that your users store in iCloud.

Next, you’ll explore how to synchronize data across a user’s devices.

Finally, you’ll discover how to handle CloudKit errors, test your app on physical devices, and deploy to production.

When you’re finished with this course, you’ll have a foundational knowledge of CloudKit that will help you provide a fluid, interactive data sharing experience.

CloudKit Fundamentals

Course Outline

1 – Setting up CloudKit

Module 1 is the introduction to the course with discussion of the motivating factors for using CloudKit, course prerequisites, storyline overview, and a demo of the end product of the course.

The demo app for this course is a fun one! I put you in the scenario where we team up to build a hazard reporting app for our company’s Safety Department.

The final product will come complete with the ability to save, query, update, and delete text, images, and location information into iCloud using the CloudKit framework.

2 – Modeling and Saving Data

Working with CloudKit begins with an understanding of the framework Types that are used to model and save data.

You'll learn about CKRecords and CKAssets, and save your first bits of data up to iCloud in this module.

3 – Querying, Displaying, Updating, and Deleting Data

Once data has been saved into an iCloud database, the next logical step is to query it and display it within the app.

I will teach about the CKQuery class for querying the CloudKit database for records and/or assets, so that data can be retrieved and displayed in the UI.

And of course, once data is retrieved and displayed, it's fair game for updating and deleting.

4 – Synchronizing Data Across Devices

The whole point of CloudKit is to make sure that data is accessible from more than one device.

One of the primary features still glaringly missing from our Hazard Reporter app at this point in the course is the fact that it doesn’t automatically update when data changes in the CloudKit database.

In this module, I'll teach you about how CloudKit uses subscriptions and push notifications to alert other users’ devices to changes that have occurred in the CloudKit database, so that appropriate action can be taken in code to respond to those changes.

I'll also simulate hazard reports coming in from another user by adding data through the CloudKit Dashboard and watching the screen update with the new data in the iOS app.

5 – Modeling Relationships Between Record Types

Modeling relationships between Record Types is important for many scenarios. In this module I will teach how to work with CKReferences in order to represent hierarchical relationships or to represent ownership between model objects.

6 – Planning for Production

Apple engineers repeatedly warn that CloudKit error handling isn’t the difference between a good app and a bad app… it’s the difference between a functional app and a non-functional app. To that end, I cover some of the most common CloudKit errors and how to handle them.

And alas, once a version of the app is ready enough to put into users’ hands, it’s crucial to test it and then put it into Production. I will discuss creating an Ad-Hoc deployment of the app so that it can be installed on other users’ devices via iTunes. I will also discuss deploying the CloudKit database schema to Production in preparation for deployment to the App Store.

Course Resources

Demos of technology in action are super important to me. That being the case, I tried to pack as much demo content into the course as possible. You'll get to see the full array of dev-time experiences, not just the final "it works perfectly” outcomes.

The course also comes complete with working Xcode projects that gradually build you up to the final version of the app, one step at a time through each module.

Feedback Welcome!

I welcome feedback on this course, and on other iOS development courses you might be interested in seeing in the Pluralsight library. Happy learning!

Core Data is an extremely powerful framework for managing and persisting data on your users’ devices. And let’s face it: saving data to your users’ devices is inevitable. The question is, which data management and persistence technology you use when the time comes for you to tackle this challenge?

“Core Data Fundamentals with Swift” will give you the essential skills you need to architect an app to use Core Data.

Core Data Fundamentals with Swift

Course Outline

1 – Getting Started with Core Data

Module 1 is the introduction to the course with discussion of the motivating factors for using Core Data, course prerequisites, storyline overview, and a demo of the end product of the course.

I had a blast making the demo app. Essentially, I put you in the scenario where we team up to build a prototype of an app that our Human Resources department has come to us with. They came to us with an idea – Over the past year or two, they’ve noticed that employee morale is down a bit. To improve the situation, they’re implementing a new Employee Recognition program. As part of the new program, they’ve come to our internal software development team to see if it might be possible to build some kind of an app that allows employees to recognize one another for jobs well-done – electronic “Shout Outs” if you will.

And that’s where you and I come in – HR wants us to prototype something up so that they have an idea of what’s possible.

Throughout the course, we work on this prototype app together!

2 -Setting up the Core Data Stack

Working with Core Data begins with setting up the Core Data Stack. You will learn how to implement the stack, how to architect your app for testability and maintenance, and how to share Core Data components (such as NSManagedObjectContext) between view controllers.

3 – Creating a Data Model

Building a data model is the foundation for persisting information with Core Data. You will learn to create a data model in Xcode, and you will understand how to work with that model in Swift code.

4 – Building Relationships Between Entities

Understanding the importance of relationships and how to build them is vital to the efficiency and expressiveness of your Core Data model. You will learn why building relationships is worth the investment, and then you will gain the skills you need to be able to build these strategic links between Entities in Xcode.

5 – Saving, Accessing, and Deleting Data

Having the ability to save data to a Core Data persistent store is essential. Being able to retrieve that data later on for display, for modification, or even for removal from the persistent store is also a critical. You will learn the mechanics of how to use the Core Data framework classes that are involved with saving, accessing, and deleting data in this module.

6 – Showing and Synchronizing Data with NSFetchedResultsController

Displaying data in a user interface and keeping it synchronized with the state of the persistent store is a critical piece of the Core Data puzzle. You will learn how to use NSFetchedResultsController for keeping table views in sync. You will also examine using the iOS Notification Center as an alternative way to detect and respond to changes in the persistent store.

7 – Changing Core Data Models

It’s inevitable: You’re going to have to change your data model from its original form sooner or later. This module will guide you in creating new versions of your data model. You will also learn how to migrate your persistent store to new data model versions so that no data is lost as you make changes.

8 – Understanding Core Data Changes in iOS 10 and macOS Sierra

Change is constant. Be prepared for the latest enhancements to the Core Data framework by understanding what’s new in Core Data with Apple’s latest platforms. You will learn about a new framework class called NSPersistentContainer that is designed to simplify the Core Data stack creation process. This concluding module will also point you to resources that will help you build on your new Core Data foundation.

Course Resources

Demos of technology in action are super important to me. That being the case, I tried to pack as much demo content into the course as possible. You’ll get to see the full array of dev-time experiences, not just the final “it works perfectly” outcomes.

The course also comes complete with working Xcode projects that gradually build you up to the final version of the app, one step at a time through each module.

Feedback Welcome!

I welcome feedback on this course, and on other iOS development courses you might be interested in seeing in the Pluralsight library. Happy learning!