Topic domain
Mobile Computing
Platform constraints and app architecture on phones and tablets.
- Articles
- 80
- Clusters
- 8
- Foundational
- 24
- Intermediate
- 32
- Advanced
- 24
OS services, sandboxing, and lifecycle.
- Process Launch: From Launcher Tap to First Instruction
- Per-App UID Isolation and the Data Directory Contract
- Lifecycle Callbacks and the Process Importance Ranking
- Saved State, Process Death, and the Bundle Size Limit
- Permission Grants and Where They Are Enforced
- Binder IPC: Parcels, Handles, and One-Way Calls
Declarative UI, layout, and state.
- Reconciliation: Turning a Declarative Description into Minimal Mutations
- Element Identity and State Retention Across Rebuilds
- Constraints Down, Sizes Up: Why Layout Is a Single Pass
- Flexbox and Weight Distribution Without a Constraint Solver
- View Recycling and Virtualization in Long Scrolling Lists
- Text Measurement and Line Breaking in Layout
Local databases, files, and sync.
- SQLite File Layout: Pages, B-Trees, and the Freelist
- WAL Frames, Read Marks, and What a Checkpoint Can Move
- Fsync Cost and Journal Modes on Flash Storage
- Atomic File Replacement: rename, fsync, and the Directory Entry
- App Container Layout and Which Files Belong in a Backup
- Running Schema Migrations Inside the App Update Window
Radio state, offline behavior, and retries.
- Radio Resource Control States and the Tail Timer After the Last Byte
- What a Connectivity Callback Reports and What It Cannot
- Counting Round Trips Before the First Payload Byte
- Retry Classification When the Failure Arrives as a Timeout
- The Durable Outbox: Committing Locally Before the Network Agrees
- Replaying a Queue Against State That Has Moved On
Scheduling limits and wakeups.
- Process Suspension and the Background Execution Grant
- Durable Deferred Work and the Persistence Boundary
- Timer Coalescing and the Deferrable Work Budget
- Push as a Wakeup Path from APNs to the App Execution Window
- Handing a Transfer to a System Daemon So It Outlives the App
- Declaring Long-Running Tasks Without Being Killed
Startup, memory pressure, and frame budget.
- Cold Start Phases and Where Launch Time Is Spent
- Frame Budget Arithmetic and the Real Deadline for Main Thread Work
- The Main Thread Message Queue and Why a Single Long Task Delays Frames
- Memory Pressure, Kill Decisions, and What an App Can Observe Before It Dies
- Allocation Rate, Heap Growth, and Garbage Collection Pauses on a Frame Budget
- Bitmap Memory and the Cost of Decoding at Full Resolution
Shared code and platform fidelity.
- The Portable Core Boundary: What Shared Code Must Not Reference
- Retained Native Widgets or an Owned Render Tree
- Marshalling Across the Language Boundary
- Shared State Without a Shared Heap
- Text Metrics and Line Breaking Across Two Font Stacks
- Back Navigation When the Two Platforms Disagree
Signing, distribution, and staged rollout.
- The APK Signing Block and Whole-File Digest Verification
- Certificate, Profile, and Entitlement Binding in iOS Code Signing
- Split APKs and App Bundles: How One Build Becomes Many Downloads
- Version Codes, Monotonic Ordering, and Downgrade Refusal
- Staged Rollout Cohorts and What Halt Actually Does
- Delta Update Patches: Source Identity, Not Just a Diff
All Mobile Computing articles
- Oct 13, 2026 Shared State Without a Shared Heap Two platform runtimes cannot hold the same objects, so cross-platform state lives in an external store with subscription and persistence semantics that the framework must define itself.
- Oct 8, 2026 Binder IPC: Parcels, Handles, and One-Way Calls How a single-copy parcel transfer works, what a binder handle actually names, and why one-way calls have ordering guarantees but no completion signal.
- Oct 6, 2026 Text Metrics and Line Breaking Across Two Font Stacks The same string occupies different space on two platforms because measurement, shaping, and fallback differ. Shared layout must pick one authority for metrics or accept divergence.
- Sep 23, 2026 Delta Update Patches: Source Identity, Not Just a Diff Why a binary delta is only applicable to the exact bytes it was computed from, how the store identifies those bytes, and why splitting an app bundle changes what a delta can save.
- Sep 3, 2026 Text Measurement and Line Breaking in Layout How a layout engine turns a string, a font, and a width into glyph positions, why shaping cannot be done per character, and how the break opportunity rules interact with measurement.
- Aug 26, 2026 Buffer Queue Depth and the Latency It Adds Between Touch and Photon How many buffers a surface holds decides whether the pipeline can overlap frames or must serialize, and why every extra buffer buys throughput with input latency.
- Aug 13, 2026 Wrapping a Native SDK Behind a Shared Interface Third-party SDKs ship as binaries with their own threading, error, and lifecycle models. A plugin boundary has to normalise all three, and the normalisation is where most integration defects originate.
- Jul 22, 2026 Version Codes, Monotonic Ordering, and Downgrade Refusal Why the installer compares an integer rather than a version string, how a version code that wraps or repeats poisons an update path, and where platform policies override monotonicity.
- Jul 1, 2026 Bitmap Memory and the Cost of Decoding at Full Resolution The byte arithmetic behind image memory, why a decode allocates more than the file size, and how sample size and format conversion change both the footprint and the time.
- Jun 10, 2026 Frame Budget Arithmetic and the Real Deadline for Main Thread Work Why the per-frame budget is smaller than the refresh period, how the pipeline splits it between CPU and GPU, and which stages can run in parallel with which.
- May 2, 2026 SQLite File Layout: Pages, B-Trees, and the Freelist How a SQLite database maps tables onto fixed-size pages, what the 100-byte header records, and why overflow chains and free pages make the file behave the way it does.
- Apr 23, 2026 Attributing Jank to a Specific Pipeline Stage A method for turning a frame timeline into one responsible stage, why the naive comparison of durations misleads, and how to distinguish queue latency from work latency.
- Apr 2, 2026 Flexbox and Weight Distribution Without a Constraint Solver How flex factors and layout weights divide leftover space, why the algorithm needs a freeze step, and what happens when the total demand exceeds the container.
- Mar 6, 2026 Process Suspension and the Background Execution Grant Why a backgrounded process keeps its memory but loses its CPU, what suspension does to timers and sockets, and how the two clock sources diverge across device sleep.
- Feb 8, 2026 Lifecycle Callbacks and the Process Importance Ranking Why an app receives stopped and destroyed notifications in a fixed order, how the platform derives that order from a ranked list of processes, and which transitions are not reversible.
- Feb 4, 2026 What a Connectivity Callback Reports and What It Cannot Why the operating system reports a network as available before it can reach anything, and which checks distinguish a captive portal from an outage from a broken name lookup.
- Jan 20, 2026 Replaying a Queue Against State That Has Moved On When queued writes finally reach the server, the world may have changed beneath them; version vectors, field-level merge rules, and conflict surfacing decide what survives.
- Jan 8, 2026 The APK Signing Block and Whole-File Digest Verification How the v2 signature sits between the ZIP entries and the central directory, how a digest covers a file that contains the digest, and why JAR signing could not do this.
- Dec 30, 2025 Timer Coalescing and the Deferrable Work Budget How a kernel batches timer expiries, how slack and tolerance let a deadline drift, and why a wakeup that can wait is worth more than one that cannot.
- Dec 17, 2025 Push as a Wakeup Path from APNs to the App Execution Window How a silent notification becomes a bounded execution window, why the push service collapses and throttles deliveries, and what the app can still be trusted to do.
- Dec 10, 2025 Per-App UID Isolation and the Data Directory Contract How assigning each installed app its own kernel user ID turns file permissions into an application boundary, what the private data directory guarantees, and where the model leaks.
- Dec 4, 2025 Class Loading and Verification Cost on the Startup Path How the runtime turns a class reference into executable code at first use, why verification walks bytecode the program may never run, and how ahead-of-time compilation changes the split.
- Nov 24, 2025 Bridging One Semantics Tree to Two Accessibility APIs A shared widget description must be projected into two different accessibility object models. The projection is lossy in both directions, and the losses are what make a screen unusable rather than merely imperfect.
- Nov 13, 2025 Wake Locks, Reference Counting, and the Cost of a Held CPU Why a wake lock is a counted system resource rather than a flag, what a partial lock actually keeps powered, and how an unbalanced acquire turns into a battery complaint.
- Nov 7, 2025 The Durable Outbox: Committing Locally Before the Network Agrees How an app records an intended write on disk, drains it in order, and survives process death, so that a user action is never lost to a failed request.
- Oct 22, 2025 Page-Level Encryption: Nonces, MACs, and the Cost of Decrypting Every Read How an embedded database encrypts individual pages with a per-page nonce and a per-page MAC, what that costs in usable page space, and why the key cache is the real attack surface.
- Sep 26, 2025 Fsync Cost and Journal Modes on Flash Storage What a flush request actually guarantees on a phone, how SQLite synchronous levels trade durability for write latency, and why the barrier between the journal and the database file is the one that matters.
- Sep 23, 2025 Shipping Shared Code Outside the Release Cycle Delivering the shared layer as a replaceable bundle decouples it from the native shell, which turns every release into a matrix of shell and bundle versions and every rollback into a data-compatibility problem.
- Sep 15, 2025 Memory Pressure, Kill Decisions, and What an App Can Observe Before It Dies How the platform ranks processes for termination under memory pressure, why a backgrounded app is not safe, and which signals give an app warning before the kill.
- Aug 22, 2025 Push Notification as a Store-and-Forward Channel Why mobile push cannot be a socket the server writes to, how the vendor service buffers and delivers, and what the delivery guarantees do and do not include.
- Aug 5, 2025 Radio Resource Control States and the Tail Timer After the Last Byte Why a cellular radio stays powered for seconds after a transfer ends, what each connection state costs, and how the spacing of requests decides which transitions are paid.
- Aug 1, 2025 The Main Thread Message Queue and Why a Single Long Task Delays Frames How a looper serializes work onto one thread, how synchronization barriers let frame callbacks overtake queued messages, and what makes a task on the queue expensive beyond its own duration.
- Jul 3, 2025 Reconciliation: Turning a Declarative Description into Minimal Mutations How a framework compares two descriptions of the same interface to derive a small set of mutations, and why the comparison is a linear heuristic rather than an exact tree edit distance.
- Jun 16, 2025 Process Launch: From Launcher Tap to First Instruction How a tap on an icon becomes a running process, why mobile systems fork from a preloaded template instead of spawning fresh, and where a cold start spends its time.
- Jun 9, 2025 Durable Deferred Work and the Persistence Boundary How a work item survives process death, what must be written before an acknowledgement is sent, and why the durable record is the only scheduler that cannot be lost.
- May 28, 2025 Staged Rollout Cohorts and What Halt Actually Does How a percentage rollout maps devices to cohorts, why halting stops new adoption but not installed copies, and what the store can and cannot undo after a release is live.
- May 23, 2025 Constraints Down, Sizes Up: Why Layout Is a Single Pass The layout protocol that passes size limits to children and returns chosen sizes to parents, why one pass suffices, and where intrinsic measurement forces a second.
- May 16, 2025 Declaring Long-Running Tasks Without Being Killed How an app asks for continued execution after it leaves the screen, what each declaration actually grants, and why the grant is audited rather than trusted.
- May 13, 2025 Cold Start Phases and Where Launch Time Is Spent The stages an app passes through between a tap and its first frame, which stages scale with code size, and why the reported launch time depends on where the clock starts.
- May 13, 2025 Reproducible Mobile Builds and Independent Artifact Verification Which build inputs leak into a mobile binary, how path and timestamp normalisation makes two builds comparable, and what a third party can actually prove by rebuilding.
- May 8, 2025 Permission Grants and Where They Are Enforced How install-time and runtime permission models differ, which layer checks a grant at the moment of use, and why a granted permission can still fail at the call site.
- May 6, 2025 The Portable Core Boundary: What Shared Code Must Not Reference Portability follows from the set of symbols a module names rather than the language it is written in, so a shared core is built by inverting platform dependencies at the edge.
- Apr 30, 2025 Handing a Transfer to a System Daemon So It Outlives the App Why background uploads and downloads are owned by a system process rather than the app, what the delegate relaunch guarantees, and where the handoff loses data.
- Apr 25, 2025 Change Logs and Tombstones for Offline-First Sync How a local database records what changed while offline, why deletes need an explicit marker, and how a sync cursor avoids replaying the entire history on every launch.
- Apr 21, 2025 WAL Frames, Read Marks, and What a Checkpoint Can Move How the write-ahead log appends frames instead of rewriting pages in place, how readers pin the log through read marks, and why a checkpoint is bounded by the slowest open reader.
- Apr 4, 2025 Exact Alarms, Doze, and the Maintenance Window How the platform suspends background work when the device is idle, what an exact alarm buys against that suspension, and why the delivery window widens with time.
- Mar 28, 2025 Rollback Without Downgrade: Containment After a Bad Release Ships Why the installer cannot un-ship a build, how remote configuration and feature gating contain a defect, and which failures those mechanisms cannot reach at all.
- Mar 17, 2025 Install Sessions: Atomicity Across Multiple Split APKs How the installer stages a set of APKs as one transaction, what commit guarantees about visibility, and what happens to a half-written session when the device reboots.
- Mar 13, 2025 Mandatory Access Control Above the UID Boundary Why a per-app user ID is not sufficient authorisation, how type enforcement composes with discretionary permissions, and what the policy costs to maintain.
- Mar 11, 2025 Allocation Rate, Heap Growth, and Garbage Collection Pauses on a Frame Budget Why per-frame allocation, not heap size, determines pause frequency, how a generational collector turns short-lived objects into a recurring cost, and what makes a collection visible in a frame.
- Feb 18, 2025 Storage Pressure: What a Device Does When the Disk Fills How the platform reclaims space from caches under pressure, why a nearly full flash volume slows down before it fails, and how an app should budget and shed data before the system does it.
- Feb 16, 2025 Intent Resolution, Exported Components, and URI Grants How a late-bound call is matched to a component, what makes a component reachable from other apps, and why a URI permission is a separate grant from the intent that carries it.
- Feb 12, 2025 Saved State, Process Death, and the Bundle Size Limit What survives when the platform reclaims an app process, how the saved-state channel is serialised through the system service, and why its size is capped.
- Nov 27, 2024 Atomic File Replacement: rename, fsync, and the Directory Entry Why a save operation that overwrites in place is not crash-safe, what the rename trick guarantees, and which flushes must bracket it for the guarantee to hold.
- Nov 22, 2024 Back Navigation When the Two Platforms Disagree Android has a system back action with predictive gestures; iOS has an edge swipe owned by the navigation controller. Reconciling them means modelling history in the shared core and restoring it after process death.
- Sep 27, 2024 One Description, Two Design Languages Material and Apple design languages differ in elevation, corner treatment, motion, and safe-area insets. A shared description has to keep semantics while letting the visual layer diverge per platform.
- Aug 29, 2024 Semantics Trees and the Platform Accessibility Bridge How a declarative interface is projected into a second tree that assistive technology reads, what the platform expects of that tree, and why merging and clearing nodes is a correctness problem rather than a labelling one.
- Aug 23, 2024 From Invalidation to Present: The Frame Pipeline on a Mobile Device The stages between a state change and a lit pixel, why the pipeline is driven by the display refresh signal rather than by input, and what happens when a stage overruns its deadline.
- Aug 18, 2024 Hit Testing and Gesture Arbitration Across Overlapping Views How a touch becomes a gesture, why the framework must decide which recognizer wins before it knows what the user intends, and how touch slop and failure requirements make that decision reversible.
- Aug 17, 2024 Recomposition Scopes: How Granularity Decides What Reruns Why a state read is only observed by the nearest enclosing scope, how dependency tracking limits the work a single value change triggers, and why state hoisting changes cost.
- Jun 23, 2024 Retry Accounting When the Scheduler Chooses the Moment How attempt counts, backoff, and jitter interact with deferral, why a retry that waits for a maintenance window needs different arithmetic, and where budgets go wrong.
- May 16, 2024 Memory Pressure, Reclaim Order, and the Kill Decision How a mobile system decides which process to kill under memory pressure, why the score is an out-of-memory adjustment rather than a priority, and how file-backed pages change the arithmetic.
- Apr 18, 2024 Certificate, Profile, and Entitlement Binding in iOS Code Signing How a provisioning profile licenses one signing identity to assert a specific set of entitlements, and why the kernel rejects an app whose entitlements exceed its profile.
- Apr 1, 2024 Running Schema Migrations Inside the App Update Window Why a migration that is safe on a server is risky on a phone, how to make each step resumable, and what to do when the migration needs more space than the device has.
- Mar 30, 2024 Retry Storms When a Network Comes Back Recovery is harder than outage: every queued client retries at once, and the mechanisms that keep a system stable are jitter, admission control, and a drain rate the server can sustain.
- Feb 29, 2024 Split APKs and App Bundles: How One Build Becomes Many Downloads Why an Android App Bundle is not installable, how configuration splits are selected at install time, and what the bundletool size model assumes about the target device.
- Dec 24, 2023 Marshalling Across the Language Boundary Every call between shared code and platform code crosses a runtime boundary with a serialisation step, a scheduler hop, and a lifetime problem. The cost is dominated by crossings, not by bytes.
- Oct 28, 2023 Retry Classification When the Failure Arrives as a Timeout A timeout is the absence of an answer, not a statement that the request failed, and the decision to retry depends on whether the server can tell a duplicate from a first attempt.
- Oct 18, 2023 Signing Key Rotation and the Proof-of-Rotation Lineage How a new signing key proves continuity with the old one, why the lineage is a linked list of cross-signed certificates, and what a device that has never seen the old key must be told.
- Oct 7, 2023 Thermal Throttling and Why Sustained Frame Rate Diverges from Peak Frame Rate How the system converts power into heat, why a workload that is comfortable for seconds becomes janky for minutes, and how frame pacing decisions change the shape of the decline.
- Jul 23, 2023 View Recycling and Virtualization in Long Scrolling Lists How list widgets bound the number of mounted children while scrolling through unbounded content, what the recycling contract requires of item views, and where the reuse goes wrong.
- Jul 4, 2023 Element Identity and State Retention Across Rebuilds Why declarative frameworks store component state in a slot list keyed by position rather than in the component object, and how that choice decides which state survives a rebuild.
- Apr 21, 2023 Code Signing and Entitlement Enforcement at Load Time What a signature actually covers on a mobile binary, how the kernel or loader checks it before the first instruction, and what an entitlement grants that a file mode cannot.
- Feb 20, 2023 Radio Tail Energy and the Cost of the Second Request Energy per byte is not a constant on a cellular radio; it depends on how long the radio stays powered, which makes request spacing a first-order energy decision.
- Jan 18, 2023 Version Vectors and Hybrid Logical Clocks for Mobile Sync Ordering Why wall-clock timestamps cannot order edits made on different devices, how a version vector detects concurrent writes, and what a hybrid logical clock adds without needing agreement on time.
- Dec 23, 2022 Retained Native Widgets or an Owned Render Tree Two architectures dominate cross-platform mobile UI: delegating drawing to the platform widget toolkit, or owning the render tree and painting it. Each fixes a different kind of fidelity and breaks the other.
- Oct 26, 2022 Open Connections When the Device Changes Its Address A handover replaces the address under a live socket; why TCP cannot follow it, how QUIC connection identifiers and path validation allow migration, and what a rebinding costs.
- Aug 17, 2022 Counting Round Trips Before the First Payload Byte A cold request on a phone crosses radio setup, name resolution, a transport handshake, and a TLS handshake before any application data moves, and each layer can be shortened.
- Aug 15, 2022 Diagnosing a Wakeup That Never Arrived A method for distinguishing a scheduler that declined from a request that was never made, using the platform logs and the app own durable records as two independent witnesses.
- Jun 16, 2022 App Container Layout and Which Files Belong in a Backup How the sandbox directory tree separates durable user data from regenerable caches, what the platform backup excludes by rule, and why the restore path is the one that breaks.