Here’s a good read for when you’re planning a data caching strategy for your Next Great Project:
Managing Consistency of Immutable Models
Immutable models have many advantages, but managing consistency can be difficult. At LinkedIn, we’ve open sourced two Swift libraries to help manage consistency and persistence of immutable models. Unlike Core Data, the API is non-blocking, exception-free, and scales well with large numbers of models and view controllers…
The natural reflex, of course, is Core Data, and these were their issues:
- The first problem we ran into was stability
- The other issue we ran into was performance
- Another issue is there are no eviction strategies
- Another point was that migrations are necessary
- The final thing for us was scalability
- Even if we were to solve all of these problems, we didn’t like the programming model that Core Data provided. One of the things we didn’t like is that all the models were mutable, and they’re not thread-safe, so when you pass it to a different thread, you need to reread from the database
We could nitpick over how serious these problems actually are if you know what you’re doing, but yeah that last one is kinda a deal. So what would a modern architecture look like, you ask?
What we really wanted to try was to use immutable models for all the data in our application. Immutable models have long been a cornerstone of functional programming languages, and with the introduction of Swift to iOS, I think that they’ve been pushing this idea of immutability. Swift has a bunch of “immutable by default” features, and personally, I’ve been learning a lot about immutability because of Swift. I’m going to list a few of the examples of why immutable models are beneficial:
We’ll assume you know those benefits already, but if not TL;DR they’re easier.
- We wanted immutable, thread safe models for the reasons which I just went over.
- We wanted consistency, so a change in one place would automatically be reflected elsewhere in the application.
- We wanted non-blocking access on all reads and writes. There wouldn’t be any disk access on the main thread.
- We wanted a simple eviction strategy. Looking at some of our peers, we saw that a lot of apps were using 200, 300, 400 megabytes of disk space, and ideally, for us, we wanted to limit it below 50 megabytes.
- We want it to scale well. Again, as I said, we have hundreds of models and view controllers, and we wanted easy migrations. Actually, we wanted to write no migration code at all, ever.
To accomplish all these things we wrote RocketData.
RocketData is a caching and consistency solution for immutable models. It’s intended to replace Core Data or at least fulfill that role in an application. It’s written 100% in Swift, and we really like it…
Definitely read it all, but here’s the secret sauce:
The Consistency Manager, as I said, is truly the engine which drives everything. It’s an entirely separate open-source library that RocketData depends on. It’s written completely in Swift, and you can use it independently.
Next up is the executive summary.
Core Data Comparison
There is no tool which will solve every problem. For many use cases, we believe Rocket Data is a better option to Core Data because of the speed and stability guarantees as well as working with immutable instead of mutable models. However, Core Data is useful for other use cases, and it’s important to consider the differences before you make a decision for your app.
Always good to have options … and this looks like a pretty sweet one!
Speaking of options, check out this related article: Core Data or Realm.