Udemy
    •  
    •  
    •  
    •  
    •  
    •  
    •  
    •  
Subscribe
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
Combine Essentials: Publishers, Subscribers, and Subjects
Rating: 2.7 out of 5(3 ratings)
277 students

Combine Essentials: Publishers, Subscribers, and Subjects

Build a strong foundation in Combine and master real-world async data handling in Swift using Publishers and Subjects.
Created byNorbert Grover
Last updated 10/2025
English

What you'll learn

  • Understand Combine’s purpose – Learn what Combine is and how it improves async programming.
  • Grasp core concepts – Master Publishers, Subscribers, Operators, and Subjects.
  • Use built-in publishers – Work with Just, Future, Timer, and network publishers.
  • Handle async streams – Manage continuous or delayed data updates.
  • Differentiate subjects – Know when to use PassthroughSubject vs. CurrentValueSubject.
  • Transform and decode data – Use Combine operators to process and decode JSON.
  • Integrate with SwiftUI – Bind Combine pipelines to SwiftUI state properties.
  • Manage subscriptions – Control stream lifecycles and prevent memory leaks.
  • Apply MVVM with Combine – Build reactive ViewModels that drive SwiftUI views.
  • Debug reactive flows – Simulate network streams and trace Combine pipelines.

Course content

5 sections • 22 lectures • 2h 43m total length

  • What is Combine?0:47

    This lecture explains what Combine actually is. It's far more than just a framework for asynchronous tasks.

  • Why use Combine, as opposed to Async Await or Escaping Closures1:24
  • Let's talk about Publishers - What are the kinds of Publishers?1:11

    This lecture discusses publishers and what they do exactly. Their relationship to subscribers isn't really simple and this lecture go on an in-depth discussion of subscribers.

  • Explain Subjects - PassThroughSubject and CurrentValueSubject1:27

    This lecture breaks down the PassthroughSubject and the CurrentValueSubject in way that is easy to understand.

  • Defining what a Stream is in the context of iOS development.1:11

    In iOS mobile development people tend to throw around the word, 'Stream', but what does it really mean? This lecture explains all of that.

  • Explaining '.sink' and '.send'.0:58

    This lecture touches on two very important concepts. '.sink' which is about attaching a publisher to a subscriber and '.send' which is about updating the subscriber with newest updates from the publisher. This is a very important distinction and this lecture clears it up very well.

  • What is a Subscriber?0:57

Requirements

  • Basic Swift programming skills – Comfortable with variables, functions, and control flow.
  • Understanding of optionals and error handling – Familiar with Optional, try, do/catch.
  • Experience with structs and classes – Know how to define and use data models.
  • Knowledge of closures – Able to write and use completion handlers.
  • Familiarity with Swift’s async/await – Understand asynchronous execution at a basic level.
  • Basic SwiftUI experience – Know how to build simple views and bind data with @State or @Published.
  • Awareness of MVVM architecture – Understand separation between Model, View, and ViewModel.
  • Some experience with JSON data – Know how to encode and decode JSON using Codable.
  • Comfort with Xcode – Able to create, build, and run Swift projects.
  • Fundamental understanding of reactive concepts – Optional but helpful; awareness that data can “stream” or change over time.

Description

Combine is Apple’s powerful framework for handling asynchronous data, event streams, and state updates in a declarative way. This course takes you step by step from the basics of reactive programming to building complete, data-driven SwiftUI apps using Combine for iOS development.

You’ll start by learning what Publishers, Subscribers, and Operators are—and how they connect data flow through your app. From there, you’ll explore two core types of Subjects, PassthroughSubject and CurrentValueSubject, to understand when to broadcast new events and when to manage application state.

Through clear explanations and real-world coding projects, you’ll learn how to:

  • Use Combine to handle network requests, decode JSON, and update SwiftUI views seamlessly.

  • Simplify async code by replacing completion handlers and async/await with data pipelines.

  • Understand the difference between stateful and stateless data streams.

  • Integrate Combine effectively within the MVVM architecture for scalable applications.

  • Manage subscriptions, memory, and data flow in reactive apps efficiently.

By the end of this course, you’ll have the knowledge and confidence to use Combine effectively in your Swift projects—making your code cleaner, more scalable, and ready for modern iOS development with reactive programming principles.

Perfect for: Intermediate Swift developers, SwiftUI learners, or anyone who wants to master Combine’s core concepts and apply them in real-world iOS apps.

Who this course is for:

  • Swift developers new to reactive programming – Understand basic Swift but want to learn Combine for async data handling.
  • iOS developers using closures or async/await – Want to know when Combine is a better alternative.
  • Intermediate SwiftUI developers – Ready to build more reactive, data-driven SwiftUI apps.
  • Developers familiar with MVVM – Want to integrate Combine for cleaner state and data flow.
  • Students building real-time apps – Working on projects with live updates, like chats or dashboards.
  • Developers exploring functional programming – Interested in applying declarative, stream-based concepts in Swift.
  • Coders managing complex async logic – Looking to simplify nested callbacks with structured Combine pipelines.
  • iOS job seekers – Preparing for professional roles that use Combine and SwiftUI.
  • Experienced developers from other ecosystems – Coming from RxSwift, Kotlin Flow, or ReactiveX and learning Apple’s native reactive system.
  • Independent learners and hobbyists – Curious builders who want hands-on experience with modern Swift concurrency tools.

Report abuse