Apple's persistence framework is sometimes said to have a bad reputation. Is that warranted? Is Core Data difficult to use? Does it have a steep learning curve? Is it a dated persistence solution?

The answer to these questions is a resounding no. Core Data isn't difficult to learn or use if you take the time to learn the framework's fundamentals. That is the number one mistake developers make with regards to Apple's persistence framework.

Over the years, I have taught thousands of developers about Core Data. That has led to a roadmap for learning Core Data and it is the roadmap I use in Core Data Fundamentals. Let me show you what that roadmap looks like.

Understanding the Core Data Stack

Several years ago, Apple finally added a class to the Core Data framework that makes it trivial to set up a Core Data stack. Setting up and understanding the Core Data stack is by far the most challenging aspect of the framework. The NSPersistentContainer class encapsulates the Core Data stack, only exposing that what most developers need.

If you are new to Core Data, then I strongly discourage you from using the NSPersistentContainer class. Why is that? Even though the NSPersistentContainer class simplifies the creation and management of the Core Data stack, it hides a lot of details you need to learn and know about.

In Core Data Fundamentals, we set up a Core Data stack from scratch. I show you that it isn't as hard as it sounds or other developers make you believe. You also learn about the NSPersistentContainer class, but that isn't what we start with.

The Core Data stack is such an instrumental piece of a Core Data application that you need to know how it operates. By setting up a Core Data stack from scratch, you learn a lot about the framework and that is the recipe for successfully integrating Core Data in a project.

The Core Data stack consists of the managed object model (NSManagedObjectModel), the persistent store coordinator (NSPersistentStoreCoordinator), and the managed object context (NSManagedObjectContext). Some Core Data stacks are more complex, but this is the basic recipe. Each of these classes has a clear responsibility in a Core Data application. I agree that it may seem daunting, but it really isn't. I promise you.

Working With Managed Objects

The NSManagedObject class represents a Core Data record. It is the base class of the models you create and use in a Core Data project and it is the class you find yourself interacting with most.

NSManagedObject heavily relies on the dynamic nature of the Objective-C runtime, but don't let that scare you. That doesn't make it hard to use. You should see the extensive API of the NSManagedObject class as an opportunity, not a challenge. Its API is a set of tools that helps you accomplish what you set out to do.

You don't need to learn about every single method of the NSManagedObject class before you can start building a Core Data application. It pays to become familiar with some, but it is fine to stick with the basics.

Versioning and Migrations

Your application evolves and so does the data model. Core Data has excellent support for data model versioning and data model migrations. Xcode has a data model editor built in that makes it trivial to manage the data model of your Core Data project.

I agree that versioning and migrations sound complex, but they aren't. Once you understand what is happening under the hood, it no longer feels daunting.

If you skip versioning and migrations, you inevitably run into problems at some point. Take the time to learn the fundamentals and save yourself a lot of problems down the road.


The biggest hurdle developers new to the framework need to take is becoming familiar with Core Data's concurrency model. Concurrency is hard, but Core Data has built-in support to operate in a multi-threaded environment. Even though concurrency is an advanced topic, it is a fundamental aspect of working with Core Data. Don't skip this.


The framework defines a number of classes to make your life as a developer easier. Earlier I talked about the NSPersistentContainer class. Another class worth a look is NSFetchedResultsController. The NSFetchedResultsController class was designed with table views in mind. It exposes a convenient API for keeping a table view synchronized with the managed objects Core Data manages. You don't have to use a NSFetchedResultsController instance to populate a table view, but it can greatly simplify your code.

In Summary

The Core Data framework has a lot more to offer. The concepts and classes I listed in this post are the fundamentals you need to grasp before you can start to use Core Data effectively in a project. That is what we cover in Core Data Fundamentals.