Pluralsight on Andrew Bancroft

SwiftUI Fundamentals

Mon, 08 Apr 2024 00:00:00 +0000

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, SwiftUI Fundamentals, you’ll quickly get up and running using Xcode 15, Swift, and SwiftUI to establish the foundational skills you need to build great user interfaces for iOS.

Resources

SwiftUI Fundamentals

Course Outline

First, you’ll see the tools and learn how to use SwiftUI to create single-screen applications with adaptive user interfaces that work on multiple devices.

Next, you’ll learn how to bring your own style to a SwiftUI user interface by customizing its appearance.

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

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 - Building Single-view Applications

Topics in this module include…

Version Check: What You Need to Get Started
The Night Watch Scenario
Creating a Single-view App
Understanding the SwiftUI Framework
Creating Xcode Previews
Understanding Views
Combining and Laying out Views
Understanding the SwiftUI Layout System
Aligning and Positioning Views

2 - Customizing UI Appearance

Topics in this module include…

Applying View Modifiers
Developing a SwiftUI Mindset
Using Icons and Symbols
Implementing Custom View Modifiers

3 - Creating Data-driven Lists

Topics in this module include…

Preparing to Work with Lists
Understanding Lists
Creating a List
Controlling a List with Data
Using Loops to Supply Content for Lists
Adding Sections and Headings
Creating Grid Layouts

4 - Building iOS Apps with Multiple Screens

Topics in this module include…

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

5 - Adding Behavior and Working With Data

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

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
Adding Images to a SwiftUI Application
Continuing your iOS Developer Journey

iOS 17 Fundamentals

Sun, 10 Dec 2023 00:00:00 +0000

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

In this course, iOS 17 Fundamentals, you’ll quickly get up and running using Xcode 15, Swift 5, and SwiftUI to build great iOS apps and tap into the latest features of iOS 17.

Resources

iOS 17 Fundamentals

Course Outline

First, you’ll see the tools and learn the core principles for designing iOS apps with adaptive, accessible, and localized user interfaces that work on multiple devices.

Next, you’ll explore how to tackle some of the most common scenarios you’ll run into when you’re building an app for iOS 17, like performing common networking tasks, managing data, adding push notifications to your application, and implementing widgets.

Finally, you’ll learn how to take your app and publish it on the App Store. 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 app ideas to iOS 17.

1 - Preparing to Build iOS 17 Applications

Topics in this module include…

Version Check: What You Need to Get Started
How to Learn iOS Development
Introducing “Improvado” - An App for Continuous Improvement
Transitioning an App to iOS 17
Supporting Older Versions of iOS
What Every iOS 17 App Needs

2 - Designing Applications for iOS 17

Topics in this module include…

Introducing Apple’s Human Interface Guidelines
Making an Adaptive User Interface
Adding and Customizing Layout Variations
Supporting Dynamic Type
Implementing Dark Mode
Working with SFSymbols 5
Making Apps Accessible
Localizing an iOS Application

3 - Performing Common Networking Tasks

Topics in this module include…

Understanding URL Sessions
Checking Network Connectivity
Sending HTTP Requests
Requesting Data from REST APIs
Inspecting HTTP Responses
Handling Networking Errors
Organizing Networking Code
Integrating Networking Tasks with SwiftUI

4 - Managing Data

Topics in this module include…

Understanding Data Management Scenarios
Encoding and Decoding Data
Managing Preferences with UserDefaults
Synchronizing Settings with iCloud Key-value Store
Configuring Apps with Property Lists
Performing File Management Tasks

5 - Adding Push Notification Support

Topics in this module include…

Understanding Notification Scenarios
Requesting Permission to Deliver Notifications
Sending Local Notifications
Sidebar: Understanding the Delegation Design Pattern
Responding to Local Notifications
Configuring an Xcode Project for Remote Notifications
Testing Remote Notifications
Making Notifications Actionable
Sending Silent Background Notifications
Setting Up a Remote Notification Server

6 - Implementing Widgets

Topics in this module include…

Adding a Widget to an Xcode Project
Configuring a Widget
Sharing Data between an App and a Widget
Making Widgets Configurable
Creating Interactive Widgets

7 - Publishing to the App Store

Topics in this module include…

Preparing to Publish Your App
Adding an App Icon
Creating an iOS App Launch Screen
Building a Release Version of Your App
Configuring an App in App Store Connect
Submitting an App for Review

Building iOS User Interfaces with SwiftUI

Sun, 22 Aug 2021 00:00:00 +0000

Designing efficient and dynamic apps is essential for taking your iOS developer skills to the next level.

In this course, Building iOS User Interfaces with SwiftUI, you’ll build upon the basic knowledge of iOS development you’ve already gained in order to build compelling iOS apps that engage your users.

Resources

Building iOS User Interfaces with SwiftUI

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.

1 - Designing Interfaces with SwiftUI

In this introductory module, we begin where the iOS Getting Started course left off and prepare you to handle next-level interface building with SwiftUI.

Topics in this module include…

Preparing to Design User Interfaces with SwiftUI
The Snowhaven Renovation Scenario
Defining SwiftUI Views
Creating Basic Designs and Layouts
Representing Data in User Interfaces
Customizing the Appearance of Views
Changing the Size and Scale of Views
Adding Effects to Views
Layering Views with ZStacks
Implementing Navigation and Displaying a Modal View

2 - Handling User Input

There’s no such thing as an app without data. In this module, I set you up for building dynamic, interactive applications by unpacking questions like:

How do we model real-world objects and concepts as data that SwiftUI can work with?
How do we integrate data into an app, so it’s usable in the right views at the right time?
And how do we load data that’s been saved… display it… and, most importantly, for this module…change it using different editing controls with SwiftUI…

Topics in this module include…

Working with Data in SwiftUI
Establishing an App’s Data Flow
Loading and Displaying Data
Editing Text Data with Text Fields
Persisting (or Cancelling) Data Changes
Working with Picker Views
Switching Between Binary Options with Toggles
Editing Numeric Data with Text Fields
Displaying Editing Controls in a Form

3 - Bringing Apps to Life with Drawing, Animation, and Gestures

SwiftUI provides you with all the tools necessary to make your apps even more dynamic by responding to user gestures like taps and swipes… The framework also gives you everything you need to express your creativity by drawing your own graphics, and adding animations throughout your apps to bring things to life.

Topics in this module include…

Understanding the SwiftUI Drawing System
Drawing with Paths
Using GeometryReader
Applying Transformations to Paths
Building Reusable Shapes
Understanding Animations
Adding Basic Animation
Animating View Hierarchy Changes with Transitions
Combining Multiple Animations and Transitions
Responding to Gestures

4 - Integrating SwiftUI and UIKit

By now, you know that SwiftUI is wonderful, but… it’s not the only Apple UI framework used in today’s Apple Developer world. UIKit is still very widely used and even includes some UI components that are not currently available in the SwiftUI framework.

As we wrap up the course, I explore the answer to this question: How can we, as developers, mix SwiftUI and UIKit to leverage the power of both frameworks?

Topics in this module include…

Preparing to Integrate SwiftUI and UIKit
Representing UIKit ViewControllers in SwiftUI
Making SwiftUI Views Compatible with UIKit
Representing UIKit Views in SwiftUI
Sharing State Between SwiftUI and UIKit
Coordinating User Interaction Between UIViewControllers and SwiftUI
Coordinating User Interaction Between UIViews and SwiftUI
Applying the Finishing Touches

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!

iOS 14 Getting Started

Fri, 04 Dec 2020 00:00:00 +0000

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.

Resources

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.

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!

Implementing In-App Purchases on iOS

Tue, 09 Jun 2020 10:03:33 +0000

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.

Resources

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!

iOS Debugging Fundamentals

Thu, 26 Dec 2019 10:03:33 +0000

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

Resources

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!

iOS Data Persistence: The Big Picture

Tue, 30 Apr 2019 10:03:33 +0000

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.

Resources

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!

CloudKit Fundamentals

Mon, 24 Sep 2018 17:58:49 +0000

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.

Course Trailer

You can check out a trailer of the course over at Pluralsight completely free.

Resources

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 Fundamentals with Swift

Sun, 02 Apr 2017 22:04:02 +0000

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.

Course Trailer

You can check out a trailer of the course over at Pluralsight completely free.

Resources

Core Data Fundamentals with Swift

Topics

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!

Managing Xcode Project Dependencies with CocoaPods

Wed, 03 Feb 2016 18:23:49 +0000

Course Outline

I try to get as practical as possible in the course. As you’re watching you’ll be “embedded” into a team of iOS developers, and you’ll explore the problems that CocoaPods can solve for you by watching the team struggle through not having a dependency manager, and then sharing in their victories as they bring in CocoaPods to ease that dependency management struggle.

The course is a progressive journey. First, the team has problems managing dependencies without a dependency manager. Then, they bring in CocoaPods to help them find and organize 3rd party libraries. Then, they start to think, “Hey, what if we could create our own CocoaPod libraries?”. Finally, they use that knowledge of how to create a CocoaPod library to set up a private repository to share code internally between projects with their team.

I’ve got four modules that cover the following topics:

1 - Introducing Project Dependency Management

I teach the basic concepts and definitions associated with “project dependency management”. What is it all about? Why does it matter? And most importantly, how is it done in the Apple Ecosystem?

2 - Managing Dependencies with CocoaPods

I guide you through installing CocoaPods, configuring your Xcode project to use CocoaPods, and working with the CocoaPods command line utility.

3 - Creating CocoaPod Libraries

This is where things turned really fun for me. :] In this module of the course, I teach you how to create a CocoaPod library, host its source code on GitHub, and publish the library to the CocoaPods Trunk.

4 - Hosting a Private CocoaPods Repository

As the capstone to the course, I teach you how to set up a private spec repository and how to configure CocoaPods to utilize it. It really is the culmination of everything learned in the prior modules, but it’s also one of the most practical strategies for sharing code between your various Xcode projects that I’ve found to-date.

In addition to the four modules of content, the course comes with an example Swift iOS app if you’re a Pluralsight Plus subscriber!

Something for Everyone

The course is targeted at beginning to intermediate level developers. I assume no prior knowledge of how to work with a dependency manager.

That being the case, I do my best to offer something for everyone. If you’ve never used a dependency manager on another platform before, I’ve got you covered – I’ll take you step by step through using CocoaPods.

If you’re already using CocoaPods in your Xcode project, maybe you can benefit from the modules on creating CocoaPod libraries yourself! If you’re already creating libraries and contributing to the open source community, what about setting up that private spec repository to share with your team internally?

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!