Skip to content
academia.sh
tr
Log in

Course Intermediate

UIKit and Bridging

Published Updated

By the end of this course

Start course

01

View Controllers

The view controller as a per-screen responsibility, lifecycle methods across the loading, appearing and disappearing stages, stack-based navigation controllers, modal and push presentation styles, a comparison of building interfaces with a visual editor and in code, and the outlets and actions that link the interface to code.

  1. 01 The View Controller Concept How a view controller carries a screen between the model and the view, and an introduction to the measurement that classifies whether a screen agrees with the model as matching, stale, missing or leftover.
  2. 02 Lifecycle Methods Measuring which lifecycle method a value is written in, whether that leaves the screen matching the model or stale, and what moving the write does.
  3. 03 Navigation Controllers Measuring that when a screen is pushed and popped in a navigation controller, a selection removed from the model stays on the list as leftover, and that the pushed screen matches the model.
  4. 04 Presentation Styles Measuring that a value entered on a note screen presented modally over another screen is written to the model but never reaches the screen beneath, and stays missing there.
  5. 05 The Visual Editor and Code-Built Interfaces Measuring that a label with a broken outlet stays stale with its placeholder text on a screen drawn in the visual editor, that a code-built label matches, and that the placeholder text the editor saves stays as leftover.
  6. 06 Outlets and Actions Measuring that an action that only updates the model and forgets the label leaves the screen stale, and that formatted text compared with the raw value counts as stale.

02

Layout and Collections

Constraint-based layout with constraints, priorities and ambiguity resolution, stack views that reduce the number of constraints, table views with cell reuse and a data source, collection views with a flexible layout definition, the delegate pattern for handing off responsibility, and low-level visual control with drawing and layer animation.

  1. 01 Constraint-Based Layout A measurement of how a constraint constant that changes in the model but is never written to the on-screen constraint counts as stale, and a constraint that is never set up counts as missing.
  2. 02 Stack Views A measurement of how a badge removed from the model but not hidden in the stack view counts as leftover, how it counts as matching once the hiding is written, and how hiding is built into the model as a visibility field.
  3. 03 Table Views A measurement of how a note of the previous row left in a reused cell counts as leftover, how a row whose model changed but was not reloaded counts as stale, and how which cell comes back is not measured.
  4. 04 Collection Views A measurement of how an item added to the data source but not announced to the collection view counts as missing, how it counts as matching once a snapshot is applied, and how the position calculation is not measured.
  5. 05 The Delegate Pattern A measurement of how a weakly held delegate that is not wired or has been released drops the call and leaves the screen stale, and how not being wired and a method that writes nothing give the same result.
  6. 06 Drawing and Layer Animation A measurement of how a ring drawn with draw(_:) stays stale when no redraw is requested, how a value returns to its old state when the model layer is not written in a layer animation, and how the duration is not measured.

03

Bridging

Declarative and imperative interfaces wrapping each other to run in the same app, incremental screen-by-screen migration of legacy code, and which interface framework to choose in which situation.

  1. 01 Declarative and Imperative Interfaces Together Measuring how a screen falls behind the model when the root view is not reassigned while embedding a declarative view in an imperative screen, and when no update is written while wrapping an imperative view in a declarative screen.
  2. 02 Incremental Migration of Legacy Code Measuring that a field not carried over stays missing on the new screen while moving a legacy screen to the new framework one screen at a time, that a field dropped from the model stays leftover on the old screen, and that the rule works per field, not per screen.
  3. 03 Choosing a Framework Measuring two screens, one declarative and one imperative, built from the same model and checked with the same rule, showing that agreement is not a criterion for choosing a framework; the closing table of the course's fifteen lessons.

Final exam

UIKit and Bridging — 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