Skip to content
academia.sh
tr
Log in

Course Intermediate

Data, Networking and Concurrency

Published Updated

By the end of this course

Start course

01

The Networking Layer

Session configuration and task types, type-safe JSON conversion, classifying network errors and retrying, token management, memory and disk caching, and transfers while the app is in the background.

  1. 01 The Network Client Session configuration and the task types; measuring, in four categories, whether the result of the six operations behind the network layer changes if they are repeated or reordered.
  2. 02 JSON Encoding and Decoding Turning a network response into a typed record and writing the record to a store; measuring how the order in which a two-version record is written changes the result.
  3. 03 Errors and Retries Classifying network errors, and measuring whether an order retried after a timeout creates a second record on the server.
  4. 04 Authentication Storing and refreshing bearer tokens; measuring whether storing two refresh responses in a different order brings back the old token.
  5. 05 Image and Data Caching The eviction rule of memory and disk caches; measuring why the same pair of operations comes out robust in an empty cache and order-sensitive in a full one.
  6. 06 Background Transfers Downloads the system keeps running while the app is in the background; measuring why re-queuing on relaunch without checking the list downloads the same file twice.

02

Concurrency

Asynchronous functions, tasks and task groups in structured concurrency, actors that isolate shared state, the safety of interface updates on the main thread, the older queue-based model and reactive streams.

  1. 01 Asynchronous Functions A measurement showing that when two operations that can suspend are awaited in sequence, the remaining stock depends on the order of reservation, while a read operation does not see the order.
  2. 02 Tasks and Task Groups A measurement showing that when the results of jointly started work are collected as a set they are independent of arrival order, while collected as an array they depend on order.
  3. 03 Actors A measurement showing that actor isolation allows only one piece of work at a time, yet the order of two requests and the repetition of a counter still change the result.
  4. 04 Main Thread Isolation A measurement showing that the operation updating the list the interface shows depends on arrival order without a version number and becomes robust with one.
  5. 05 Queue-Based Concurrency A measurement showing that jobs added to a serial queue keep their order, but that appending and assigning a value fall into different classes under repetition and order.
  6. 06 Reactive Streams A measurement showing that a repeated subscription to a publisher repeats the request, that a shared stream stays robust, and that the operator dropping consecutive repeats depends on the pair of values.

03

Persistence

Saving small settings, storing secret values in the keychain, directory types and backup rules, the relational local database, object persistence frameworks, cloud sync across devices, and the registration and permission flow of push notifications.

  1. 01 Simple Preference Storage A measurement of how the order in which two screens write to the same key, the repetition of a launch counter, and a default value change the outcome when a small value is stored persistently.
  2. 02 The Keychain A measurement of how adding the same item a second time changes the status code where secret values are stored, and how an update-or-add operation is order-sensitive.
  3. 03 The File System A measurement of the repetition and order sensitivity of appending, full replacement, and directory creation where larger data is written to files.
  4. 04 Local Databases A measurement of how an upsert with a primary key is robust, how inserting with an auto-increment key is sensitive, and how the read order changes the result.
  5. 05 Object Persistence Frameworks A measurement of how creating and saving objects in a context is repeat-sensitive, how saving with a unique constraint is order-sensitive, and how the constraint changes the class.
  6. 06 Cloud Sync A measurement of how the arrival order of values decides the result when two devices write the same record, how a per-field set union is robust, and how the server rule changes the class.
  7. 07 Push Notifications A measurement of how raising the badge locally on a notification from the server is repeat-sensitive and how an absolute badge value in the payload is order-sensitive, and the wrap-up table of the nineteen lessons of the course.

Final exam

Data, Networking and Concurrency — Final Exam

In preparation

This course's question bank is not complete yet. The exam opens here automatically once enough questions are added.

Start typing to search.

↑↓ ↵ Esc navigate · open · close