Swift Charts for iOS Developers: Build Better Data-Driven UI

In this video, you'll learn how to analyze a JSON file and convert it into a usable Swift model. We’ll cover what models are, how JSON is used as a data source, and walk step-by-step through the process of defining Swift structs that match the JSON structure.

You’ll learn how to:

• Identify and replicate JSON structure in Swift using Codable models

• Handle nested objects and arrays with separate model types

• Manage optional and nullable fields safely

• Decode JSON data using JSONDecoder

• Use the resulting models for previews, testing, or live data loading

By the end, you’ll understand how to transform raw JSON into structured, type-safe Swift code that integrates cleanly with your SwiftUI or UIKit app.

In this video, you'll learn how to interpret JSON syntax and translate it into Swift models using the Codable protocol. We break down the structure of JSON—arrays, objects, key-value pairs, and nested components—and show how each part maps directly to Swift structs.

You’ll learn how to:

• Identify JSON arrays ([ ]) and model them as Swift arrays

• Work with JSON objects ({ }) and define matching Swift structs

• Convert JSON key-value pairs into Swift properties

• Handle nested JSON objects and arrays with custom model types

• Use optional properties for null or missing values

• Build a clear, maintainable model structure that mirrors your data source

By the end of this video, you’ll be confident in reading JSON and building Swift models that decode cleanly and integrate with SwiftUI or UIKit. This is a foundational skill for working with APIs, mock data, and local JSON files in any iOS app.

This video gives you a quick look at the Boxer Profiles app you'll build. You'll see a SwiftUI list of professional boxers loaded from JSON, tap into detailed views with records and fight history, and experience smooth data loading and error handling using a custom service layer.

In this video, you'll learn how to create a modular and testable service layer in Swift for loading boxer profile data from a local JSON file. We walk through the entire process, including:

• Creating the Service Protocol (BoxerServiceProtocol): Learn how defining a protocol establishes a contract for loading data asynchronously using Swift's async/await.

• Defining Custom Errors (BoxerServiceError): See how to build a custom error type that handles file-not-found and decoding issues cleanly.

• Implementing the Service (BoxerService): Watch as we implement the protocol with real logic to load and decode JSON data from the app bundle, simulating a network delay using Task.sleep.

This approach separates concerns, supports dependency injection, and makes your codebase easier to test and maintain. Perfect for iOS developers looking to level up their architecture skills using Swift's modern concurrency and error handling features.

This video explains how the BoxerViewModel connects your SwiftUI views to the boxer data. You'll learn how it uses a service protocol to asynchronously load profiles, publish updates to the UI, and retrieve pro records for specific boxers. We’ll break down the use of @Published, @MainActor, and why ObservableObject makes your data reactive in SwiftUI.

In this lesson, you'll build a dynamic ContentView that serves as the core interface of the boxing stats app.

You will learn how to:

• Structure a NavigationView combined with ScrollView and VStack for a responsive layout

• Connect a @StateObject ViewModel for asynchronous data loading and initial state management

• Implement a dynamic Picker to allow users to select different boxer profiles

• Display professional records including Wins, KOs, Losses, and Draws using SwiftUI views and SF Symbols

• Create visual data representations using Swift Charts with SectorMark for pie charts and BarMark for bar charts

• Transform model data into chart-ready segments for clear and interactive visualizations

• Write modular, readable SwiftUI code that follows best practices for maintainability and performance

By the end of this video, you will have a clean and functional SwiftUI view capable of presenting real-time user data in both textual and graphical formats.

Chart Coding explanation

In this video, you’ll learn how to use the RecordSegment struct as a presentation model to transform raw boxing record data into a SwiftUI-friendly format. Unlike core models like BoxerProfile or Record, RecordSegment isn’t part of the JSON data—it’s created purely to support UI rendering.

We’ll cover:

• Why RecordSegment is marked as Identifiable for use in ForEach

• How it maps simple data like wins, losses, and knockouts into labeled, displayable units

• How to build an array of segments from a Record

• How to display the segments in SwiftUI using ForEach and HStack

By the end of this video, you’ll understand how to bridge your backend data and your UI layer using lightweight view models like RecordSegment, enabling cleaner, modular, and more testable SwiftUI code.

In this video, you'll learn how to successfully run the LiveUpdateForCharts SwiftUI application in Xcode. We'll guide you step-by-step through launching the project, building the app, and running it in the simulator. We've also included the repository URL as resource, so that you can download and run it on your computer. You'll see how the UI loads chart data dynamically and what to expect from the live update behavior. This walkthrough ensures you're ready to follow along with the rest of the course and troubleshoot any build or runtime issues before diving deeper into charts and view models.

In this video, you'll learn how to create a MockBoxerService that mimics your real BoxerService by conforming to the BoxerServiceProtocol. This mock service returns hardcoded or test JSON data instantly, bypassing file access or delays. We'll use it to support SwiftUI previews and unit tests, allowing you to develop and debug UI components without relying on real data loading or asynchronous operations. This is essential for building testable, maintainable apps with clean architecture.

In this video, you’ll learn how to build a BoxerViewModel that serves as the bridge between your data service and SwiftUI views. We’ll walk through using @Published to expose boxer data, injecting a service conforming to BoxerServiceProtocol, and using async/await to load profiles cleanly. You’ll also see how to encapsulate logic like retrieving individual records, and how this ViewModel supports testability and reusability across the app.

In this video, you’ll learn how to build the BoxerBarChartView, a SwiftUI view that uses the Charts framework to visualize a boxer’s win/loss record. We’ll walk through setting up the view with @StateObject, iterating over data from the BoxerViewModel, and using RectangleMark to draw bar charts for each boxer. You'll also see how to use a computed property (recordSegments) to cleanly map raw record data into chart-ready format. This video demonstrates how to connect your model, view model, and chart-driven UI in a clean and modular way.

In this video, you’ll learn how to enhance your SwiftUI charts using RuleMark and RangeMark—two powerful tools for adding contextual reference points to your data visualizations.

We’ll cover:

• How to use RuleMark to draw benchmark lines or thresholds

• How to use RangeMark to shade ranges for tolerance bands or confidence intervals

• Customizing appearance with styles, colors, and transparency

• Combining both marks to show performance bands with target lines

You’ll see practical examples and learn how these elements make your charts more informative, especially for financial, scientific, or performance-based apps. By the end, you’ll know how to use RuleMark and RangeMark to clearly communicate key values and ranges to your users.

In this video, you'll learn how to compare multiple related data series in a single SwiftUI chart using Swift Charts. By leveraging grouping and overlay techniques, you can clearly visualize trends, contrasts, and targets across shared axes.

We’ll walk through:

• Grouping data by categories like names or labels using series

• Automatically applying styles and legends for grouped series

• Overlaying reference lines or markers on top of base charts

• Enhancing clarity with .foregroundStyle, .symbol, and .chartLegend

• Practical examples like tracking win records across athletes

Whether you’re comparing metrics over time, visualizing targets, or layering chart types, this lesson will help you create charts that are both data-rich and easy to interpret.

In this lesson, you’ll learn how to elevate your SwiftUI data visualizations using annotations, tooltips, and custom legends in Swift Charts. These features add context, clarity, and interactivity to your charts—making them more insightful and easier for users to interpret.

You’ll learn to:

• Use annotations to highlight peak values, thresholds, or specific points

• Simulate or leverage tooltips for interactive data exploration (iOS 17+, macOS Sonoma+)

• Customize legends to clearly distinguish between grouped series

• Improve visual clarity with smart layout, positioning, and formatting

By the end of this video, you’ll know how to guide user interpretation through purposeful design elements, making your charts not only beautiful but also meaningful.