iOS development by tanaschita.com

Many standard SwiftUI views include accessibility support out of the box.

As a test suite grows, we often end up writing multiple test functions that exercise the same behavior with slightly different inputs.

When building a search feature, we usually want results to update as the user types.

Live Activities let users follow an ongoing event without repeatedly opening our app.

When a SwiftUI toolbar contains more actions than the available space can hold, the system decides which items remain visible and which ones move into the overflow menu.

One possibility to control SwiftUI alerts and confirmation dialogs is with a Boolean binding.

Until iOS 27, SwiftUI's swipeActions modifier worked with rows inside a List.

SwiftUI provides the @FocusState property wrapper to observe and control focus in a view hierarchy.

URLSession is the foundation framework for loading data over the network in Swift.

When building an iOS app, we eventually need to run it on a real device, send it to testers, or distribute it through the App Store.

Widgets give users a lightweight way to see useful information from an app without opening it first.

SwiftData integrates naturally with SwiftUI.

When working with Swift concurrency, we often pass values between tasks, actors, and async functions.

Many iOS apps include third-party dependencies, such as analytics SDKs, networking libraries or crash reporting tools.

Apple's Foundation Models framework gives us access to language models directly through a native Swift API.

Swift's defer statement is useful for cleanup logic.

When working with SwiftUI, we constantly compose views from other views.

Push notifications allow us to inform users about updates even when they are not actively using the app.

When developing iOS apps, we often need to persist sensitive user data such as passwords, authentication tokens, or cryptographic keys.

SwiftUI provides built-in support for animations.

When developing iOS apps, we sometimes need to display a locally stored HTML file, for example static help pages, terms and conditions, or release notes bundled with the app.

When working with larger datasets, loading everything at once is often unnecessary.

Some apps, such as Apple Maps or Google Maps, use a draggable bottom sheet to let users switch between the main content, for example a map, and additional information presented in a sheet.

When working with in-app purchases, testing different purchase scenarios is an important part of development.

When developing an iOS app, we often need to persist data that doesn't naturally fit into a database or UserDefaults.

When developing an iOS app, we often need to bring the app into a very specific state, for example when reproducing bugs or testing edge cases.

Many existing iOS projects still rely on Localizable.strings and Localizable.stringsdict files for localization.

Localization is an essential part of many iOS apps.

Swift's Codable protocol makes it straightforward to convert JSON data into native Swift types and vice versa.

Passkeys are credentials built to eliminate security problems like weak or reused passwords, credential leaks and phishing attacks.

When working with persistence in iOS apps, schema changes are inevitable.

When working on iOS projects, we often need small automation tools.

When building SwiftUI apps, we sometimes still need UIKit.

SwiftUI's current state-of-the-art approach to state observation is the Observation framework.

This article provides a visual cheat sheet of common Combine operators, with a diagram for each one to illustrate how values flow through a pipeline.

String Catalogs provide a type-safe way to handle plural forms across languages.

Combine allows us to model asynchronous workflows declaratively.

UserDefaults is often the first place we reach for when we want to persist small pieces of data.

Working with JSON in Swift is usually straightforward.

SwiftUI's Grid gives us a way to build two-dimensional layouts without using nested HStack/VStack combinations.

Interactive notifications let users take action without opening the app.

Swift's concurrency system gives us a clean, readable way to express asynchronous work using async/await and tasks.

Associated domains create a secure, system-managed connection between an iOS app and its matching website, allowing us to support features like universal links, shared web credentials with password auto fill or app clips.

When working with associated domains, for example to support universal links, shared web credentials, or App Clips, iOS fetches the apple-app-site-association (AASA) file through Apple's CDN, not directly from the server where the file is hosted.

Before Swift introduced structured concurrency and async/await, most asynchronous APIs in iOS used completion handlers.

When we explored how we can use AsyncStream to implement reactive-style listening patterns, we also talked about one of its limitations: Swift's standard library doesn’t include many operators for transforming or combining asynchronous values.

When we explored structured and unstructured tasks, we saw a small example of using Task {} vs.

Swift's concurrency system gives us different ways to create and manage asynchronous work: some tasks are automatically tied to a scope, while others run independently.

Combine's subjects such as PassthroughSubject or CurrentValueSubject have long been the go-to way to implement reactive observer patterns across an app.

Since iOS 18, buttons, toolbars, and other controls can appear in Apple's new glass button style.