Santorini and design systems
Santorini’s shared colors and materials offer a way to think about consistency in product design.
Understanding JWT authentication
How cookies, sessions, and JWTs handle authentication, with a look at token structure, tradeoffs, and security considerations.
How file systems work
Explore files, directories, allocation methods, free-space management, and disk scheduling.
Continuations in Swift Concurrency
Bridge callback-based APIs to async/await and understand the difference between checked and unsafe continuations.
Strong, weak, and unowned references in Swift
Compare how strong, weak, and unowned references affect object lifetimes under ARC.
ARC and memory management in Swift
How reference counting manages object lifetimes, and how to break strong reference cycles.
How operating systems manage memory
Understand logical and physical addresses, memory protection, and when address binding takes place.
Three ways to download images in Swift
Compare escaping closures, Combine, and async/await by implementing the same image download.
Understanding deadlocks
The four conditions for deadlock, resource-allocation graphs, and strategies for prevention, avoidance, detection, and recovery.
Error handling in Swift
Define errors with Error and throws, then handle them with do-catch, try?, and try!.
Bridging UIKit and SwiftUI
Use makeUIView, updateUIView, and a coordinator to connect UIKit views with SwiftUI state.
Connecting views with matchedGeometryEffect
Use a shared namespace and ID to animate smoothly between different views.
Reusable code with Swift generics
Reduce duplication with generic functions, generic types, and type constraints while preserving type safety.
Understanding Swift inout parameters
Use inout to modify a caller’s variable and understand its copy-in, copy-out behavior.
Placing content with safeAreaInset
See how edge and spacing affect the safe area when adding content at the top or bottom of a view.
Resizable sheets with presentationDetents
Set available sheet heights and control the selected height with a binding.
How quicksort divides and conquers
Follow pivot selection, partitioning, and recursion, and compare average and worst-case complexity.
How bubble sort works
Understand repeated adjacent comparisons and swaps, and why bubble sort usually costs O(n²).
Time complexity and Big-O notation
Compare how algorithmic cost grows with input size, from constant time to exponential time.
Publishers and subscribers in Combine
Follow how Combine emits and receives values, manages subscriptions, and transforms streams.
Escaping closures in Swift
Understand closure lifetimes, captures, and memory management when work continues after a function returns.
Managing local state with @State
Understand how @State stores view-owned values and triggers updates when they change.
Sharing state with @EnvironmentObject
Inject an ObservableObject into the environment and read it from the descendant views that need it.
Object state and ownership in SwiftUI
Compare ObservableObject, @Published, @ObservedObject, and @StateObject, with a focus on ownership and lifetime.
Separating data models in SwiftUI
Move data out of view code and use Identifiable models in lists and detail views.
Reading layout with GeometryReader
Use available size and coordinate spaces to build layouts that respond to their actual container.
Controlling scroll position with ScrollViewReader
Identify a view, scroll to it with scrollTo, and choose its alignment with an anchor.
Managing navigation with NavigationStack
Represent navigation as values using NavigationLink, navigationDestination, and NavigationPath.
Saving preferences with @AppStorage
Connect UserDefaults to SwiftUI to persist simple settings and keep the interface in sync.
Choosing Korean particles in Swift
Inspect the final Hangul syllable to choose the correct Korean subject particle.
Handling taps with onTapGesture
Recognize single and repeated taps with onTapGesture and its count parameter.
Unwrapping optionals with if let and guard let
Compare local conditional handling with early exits when working with optional values.
The kernel at the heart of an operating system
How the kernel mediates access to hardware, manages resources, and organizes its responsibilities.
Animating insertion and removal in SwiftUI
Use transitions and animation to control how views enter and leave the hierarchy.
When onAppear and onDisappear run
Use appearance callbacks for setup and cleanup while accounting for repeated appearances.
What does an operating system do?
An introduction to the software that manages hardware resources and provides an environment for applications.
Offering choices with ActionSheet
Configure action buttons, manage presentation state, and compare ActionSheet with confirmationDialog.
Configuring alerts in SwiftUI
Build alert titles, messages, and buttons, and control presentation through state.
Building and editing SwiftUI lists
Create rows and sections, add deletion and reordering, and customize the list’s appearance.
Conditional views in SwiftUI
Use conditions and logical operators to display different content for different states.
Connecting parent and child state with @Binding
Let a child read and update a value while its parent remains the source of truth.
When to use LazyVStack and LazyHStack
Compare lazy stacks with regular stacks and understand when child views are created.
Scroll direction and indicators in SwiftUI
Arrange scrollable content vertically or horizontally and control the visibility of scroll indicators.
Data-driven views with ForEach
Generate repeated views from ranges and identifiable collection elements.
Reusable SwiftUI views with initializers and enums
Configure one view for different content and styles using initializer parameters and explicit enum cases.
Sizing and rendering SwiftUI images
Load images, control fit and fill, apply masks, and customize template rendering.
Spacing with padding and Spacer
Compare space added around a view with flexible space distributed inside a stack.
Layouts with VStack, HStack, and ZStack
Arrange child views vertically, horizontally, or in layers, and control their alignment and spacing.
Backgrounds and overlays in SwiftUI
Place content behind or in front of a base view, and understand alignment and modifier order.
Understanding SwiftUI frames
Explore how width, height, and alignment affect the relationship between a view and its parent.
Using SF Symbols in SwiftUI
Load system symbols and adjust their size, weight, color, and rendering mode.
Creating gradients in SwiftUI
Compare linear, radial, and angular gradients using the same set of colors.
Creating and applying colors in SwiftUI
Use system colors, custom values, and asset colors, and apply them to views and shadows.
Drawing basic shapes in SwiftUI
Create circles, rectangles, and capsules, and customize them with fills and strokes.
Styling and aligning Text in SwiftUI
Control fonts, weight, alignment, spacing, and sizing when displaying text.
Swift conditionals: if-else and switch
Choose between Boolean conditions and pattern matching, and use ranges and fallthrough deliberately.
Swift enums and raw values
Model related choices with enums and use type inference and raw values to work with valid states.
Comparison, logical, and bitwise operators in Swift
Build Boolean conditions, combine them with logical operators, and use OptionSet for meaningful bit flags.
Swift loops: for-in, while, and repeat-while
Choose a loop based on the data to traverse and when its stopping condition should be checked.
Swift collections: Array, Dictionary, and Set
Compare ordering, key-based lookup, and uniqueness, with examples of basic collection operations.
Any, AnyObject, and function types in Swift
Understand broad value types, argument labels, and functions as first-class values.
Basic types and strings in Swift
Compare numeric and Boolean types, then explore characters, strings, and Unicode-aware access.
Variables, constants, and naming in Swift
Choose var or let, use clear names, and sketch control flow before writing complex logic.
Functions, loops, and string interpolation in Swift
Separate work into functions, repeat it with for-in, and control formatted output with print.
Git forks and pull requests
Follow a contribution from a fork through branch tracking and a push to a pull request.
Computational thinking and Git basics
Connect data representation, algorithms, abstraction, and computer architecture with version control.