No other Remedy action game—not even Max Payne—has felt this fun.
Max Payne sits just below a few Bioware games as one of my favourite games of all time. Guess I’ll have to pick up Control!
Ah, shit. Life in Pieces has been cancelled after four seasons. It was a super adorable, very funny family sitcom. The first three seasons are on Netflix. Definitely worth checking out.
I’m listening to music from the original Mass Effect and I am having some very intense nostalgia.
Oh man. Pixar’s Coco. They know how to turn on the waterworks, right on cue.
TLDR: Table view (and collection view) data source should be backed by a snapshot of your data store; not a real-time view of it.
I attended last week’s iOS KW meetup, which was a talk by Chris Liscio about Collection View Controllers on iOS and macOS. The talk was good, featuring a lot of interesting details of how Chris implemented the main view in his music app, Capo. But what was really interesting is what I learned in chatting with him afterwards. I’ve been doing iOS development for more than 6 years, and this finally flipped a switch in my brain about why managing updates in table views (and collection views) was always so difficult for me.
Animating updates to a
UITableView’s contents is ostensibly pretty easy—you get notifications about the contents of your data store, and you tell your table view which rows were added, removed, or updated. In order to have things animate all together nicely, you do this in a transaction:
tableView.insertRows(at: [IndexPath(row: 3, section: 1)], animation: .automatic)
tableView.reloadRows(at: [IndexPath(row: 0, section: 0)], animation: .automatic)
However, there are some arcane rules about the order in which these updates are processed—not in the order in which you submit them, but all reloads first, then deletes, then insertions. In other words, reloads and deletes are processed relative to the state of the table before you begin making any updates, and insertions are processed relative to the state of the table once deletions have completed.
In the past, when I had to make updates based on a completed network request, for instance, I would call
tableView.beginUpdates(), then respond to KVO notifications by calling
insertRows() and its friends as the network response handler added, updated, and removed items in the data store, and then call
endUpdates() when processing was complete. Since the updates to the data store could happen in any order, it was extremely difficult to try to re-order everything so that it would make sense in the order that
UITableView performs its updates. Crashes occurred often. This was also a source of high coupling between classes that should have little or now knowledge of each other.
It turns out the answer is very simple. As Chris described, your data source should represent a snapshot of your data, not a real-time view of it. After changes have finished, you move your snapshot forward, compute a diff, and send the necessary insert / delete / refresh messages to the table view. This is apparently what
NSFetchedResultsController does under the covers, and other technologies such as Realm allow you to either update your thread’s snapshot manually or at the beginning of a runloop.
The key is that any changes that occur in your
UITableViewDataSource should only happen during a table view updates transaction. If your data source reflects the real-time state of your backing store, values might have already changed by the time you’re responding to a them, which can get you into trouble with the frameworks.
So, lesson learned, 6+ years later: `UITableViewDataSource` shouldn’t represent live data. Move your snapshots forward during your table view’s update transactions. Have fewer crashes.