Top-notch video tutorials for Swift developers

Thousands of developers use NSScreencast to stay on top of iOS development.

ExxonMobil
Venmo
Thoughtbot
The Working Group
Medium

Updated Regularly

Bite-sized videos on iOS development.

The iOS landscape is large and changes often. With short, bite-sized videos released on a steady schedule, NSScreencast helps keep you continually up to date.

Up to date with Xcode 15 and iOS 17

We cover the latest and greatest to get you up to speed quickly.

UIKit, SwiftUI, SwiftData, and macOS

In our catalog you'll find a wide variety of topics and UI frameworks.

Swift Language

Increase your knowledge of the Swift language and take advantage of new Swift language features as they are developed.

High Quality Videos

We stress the details. Each screencast is carefully produced in HD quality.

Short and Focused

We don't want to waste your time. Most videos are between 10 and 20 minutes long.

Any Device

Stream on the web or use our native apps for iOS or the tv.

Team Plans

Get NSScreencast for your whole team. Discounts start at 5 seats
Steven Tolton

Have I mentioned lately how awesome NSScreencast is? No? Worth the subscription. Check it out if you’re an iOS developer. Or even if you’re not and you want an example of how to do coding screencasts well.

Foster Bass

Got tired of dead-end googling so I checked to see if @NSScreencast had covered what I was looking for. Of course he had, 4 years ago. Should have checked there first.

Aijaz Ansari

One 13-minute episode of @NSScreencast just paid for the yearly subscription fee in amount of time saved. Do it.

Sam Soffes

Seriously great stuff even for seasoned developers. I’ve learned a good amount from Ben’s videos.

James Dempsey

You can really expand your development horizons in just a few minutes a week with NSScreencast.

Alexis Gallagher

Random PSA for iOS developers: @NSScreencast is a great resource, and worth every penny. It’s high quality, practical, and honest.

Nate Armstrong

Can’t say enough good things about @NSScreencast There is gold in the Road Trip DJ Series.

Karl Oscar Weber

I just reuppped my subscription to @NSScreencast. [An] indespensible resource if you’re into iOS or Mac Development.

Marcus Ziadé

Just finished @NSScreencast series on Modern CollectionViews. Strongly recommended. Programmatic UI, nicely structured code, easily approachable explanation style. 👌

Showing episodes 121 - 144 of 584 in total
  • Command Line Apps In Swift - Parsing Arguments

    #464

    Command Line Swift

    I use a collection of command line scripts that help me in the production of NSScreencast episodes. Most are written in Ruby, which is a language I know and love, and some are written in bash, which is... a language. I sometimes wonder what these scripts would look like if I were to write them in Swift. So in this new series I'm going to explore rewriting a script that I use to encode videos using Swift. In this episode we'll bring in the excellent Swift Argument Parser library and use it to give us a clean and consistent command line interface to start with.

  • Data Fetching and Caching with Pigeon

    #463

    Pigeon is an interesting and powerful library for SwiftUI and UIKit for fetching and caching data. In this episode we will explore the library and how we can use it to build a simple Star Wars Universe explorer app using the Star Wars Dev API.

  • Working with Measurements in Swift

    #462

    Foundation has a wonderfully useful support for dealing with measurements like distances, durations, temperatures and more in Swift. The Measurement class combines with a Unit type to constrain the measurements into their own domains. With this you can get functionality like conversion and addition. With MeasurementFormatter we can format these values for display in our UI based on the user's locale. In this episode we will explore how to use this API, how to extend the existing dimensions to add new measurement values, and how to create your own domain of measurements. For this we will model Throughput of Items in the game Factorio.

  • Testing with Resolver

    #461

    One of the benefits we can get by programming to protocols and leaving our concrete implementations isolated, is that we enable swapping out these dependencies for different ones for use during tests. Doing so will require us to restructure our app setup a bit so we can have a completely separate AppDelegate and SceneDelegate for use in testing. With this setup we can control the environment completely. We'll setup mock dependencies that we can verify that the interaction with these dependencies is as expected.

  • Dependency Injection with Resolver

    #460

    Managing dependencies can be a pain. Unless you're using shared instances accessible everywhere, you end up having to pass along dependencies from class to class. One strategy for decoupling your types from external dependencies is to create protocols and "inject" the actual concrete implementations at runtime. This enables you to test them easily and also isolates library-specific APIs from the rest of your application. This can make switching between libraries more feasible. In this episode we'll take a look at a library called Resolver that does this. Technically it implements Service Location rather than Dependency Injection, but the result is similar.

  • Item Anchors

    #459

    Working with Modern Collection Views

    Using Item Anchors we can position decoration views anchored to our layout items. This is could be used to outline or underline items, or in our case to add a little unread indicator badge to our items.

  • Using the Layout Environment

    #458

    Working with Modern Collection Views

    Not every layout will be appropriate for every screen size. In this episode you'll see how you can use the layout environment when constructing your compositional layout to provide a more suitable layout for iPad.

  • Background Decoration Views

    #457

    Working with Modern Collection Views

    One of the things you'd get for free with UITableView in the grouped style is a nice rounded rect background around your sections. With UICollectionView, you can implement these with background decoration views. We'll see how to set these up in our compositional layout to give the series section a different feel.

  • Heterogeneous Sections

    #456

    Working with Modern Collection Views

    Our Diffable Datasource and snapshots are generic over the type of data that we pass to the cells. So how can we make sections with completely different data? In this episode we'll cover one approach which involves defining an enum with associated data for each of the sections. We'll use this to add a Series strip of data mixed in with our collection view.

  • Section Headers

    #455

    Working with Modern Collection Views

    In this episode we'll make a custom header view to give some of our sections a title. The approach we use here with compositional layout is more flexible than with UITableView. We'll start with a UICollectionReusableView implementation for our header, add the desired item to our layout, and then vend the desired view using the datasource's supplementaryViewProvider.

  • Diffable Datasource Snapshots

    #454

    Working with Modern Collection Views

    Diffable datasources provides a great API for driving your collection view updates in a transactional, state-driven way. We no longer have to manually call insert/delete/move rows when the data is changed. Instead, we apply a new snapshot and the changes are made for us, including animations.

  • Compositional Layout

    #453

    Working with Modern Collection Views

    First introduced in iOS 13, UICollectionViewCompositionalLayout is an amazing and powerful addition that gives you lots of flexibility when describing layouts. There are a few new types to get used to (namely sections, groups, and items) but they all work together allowing you to keep layout separate from your views and your data.

  • Collection View List Layout

    #452

    Working with Modern Collection Views

    With UITableView no longer being encouraged for use, we need to replace this behavior with UICollectionView. This is where UICollectionViewListLayout comes into play. Using this layout we can get the familiar table view appearance in plain and grouped styles (as well as additional styles to support sidebars on iPad and macOS). This includes support for sticky headers and footers, swipe actions, and other UITableView behaviors that we've come to rely on.

  • Cell Registration

    #451

    Working with Modern Collection Views

    In this episode we migrate our collection view to use the new cell registration API. Using this API we no longer need to cast dequeued cell types to our custom types. Instead, we set up the registration object with the cell type and the data we'll be passing to each cell. This further reduces the code we have to write in our datasource implementation and gives us more flexibility on how and where cells are configured.

  • Setting Up

    #450

    Working with Modern Collection Views

    In this episode we review the basic example app and start setting up our collection view in code. We start with the basic flow layout which is most common. Later we'll refactor this to use the newer style, but this episode introduces the series and sets up the foundation we'll build upon.

  • Customizing Animations with AnimatableVector

    #449

    If you can describe your animation with a small number of parameters that interpolate over the animation, animation is pretty easy. But once you want to combine an arbitrary number of animatable data values, for instance an array of Doubles representing our points, then you have to resort to a custom VectorArithmetic implementation. In this episode we will create an AnimatableVector type that is capable of animating between arrays of Double values. We then use this type to animate between 2 sets of points using our waveform algorithm.

  • Animatable Modifiers

    #448

    Animating in SwiftUI can seem like magic, until you want to animate something custom. In this episode we'll add animation to our frequency, amplitude, and phase parameters for our waveform by leveraging SwiftUI's AnimatableModifier protocol. We'll see how to implement the animatableData property with one, two, and ultimately all three parameters. We'll cover implicit and explicit animations, as well as the behavior when attempting to mix animations.

  • Rendering Waveforms in SwiftUI

    #447

    I've been working on rendering waveforms using mathematical functions and have found the experience to be both fun and enlightening. In this episode we will develop a method to render arbitrary functions using a Shape, then explore some mathematical concepts that can help us render a nice looking waveform that could be use to indicate activity in sound, speech, or other effects.

  • Bounce Animation in SwiftUI

    #446

    Simple animations in SwiftUI are refreshingly easy. However, some animations are deceptively tricky, as we don't have access to completion handlers. Animation is entirely state-based, so if we have an animation where an item needs to move and return to its original state, we need to take a different approach. In this episode we will model a bounce animation using a simple sine function, feeding in the time value t using SwiftUI's linear animation interpolation.

  • SwiftUI Grids

    #445

    With the introduction of LazyVGrid and LazyHGrid In iOS 14 we now have access to much more powerful grid-based layouts in SwiftUI. In this episode We will examine the different types of layouts we can accomplish with flexible, fixed, and adaptive sizing for our rows and columns. We'll look at how animations work between different layouts, and how to consider larger screen sizes.

  • SwiftUI Native Progress Views

    #444

    A few episodes back we covered how to wrap a UIActivityIndicatorView to show loading progress in SwiftUI. Now in iOS 14 this is built in. In this episode we'll cover the various styles, how to hook it up to a Progress instance, and how to create your own custom progress visualizations.

  • SwiftUI Lazy Stacks in iOS 14

    #443

    iOS 14 Beta is now available and one of the new features is Lazy stacks. With a normal stack, all the layout happened at once, which meant poor performance for large lists of content, grids, etc. With Lazy stacks the views are only created when they first come on screen, greatly increasing the usefulness of stacks for large or infinite collections of content.

  • SwiftUI Anchor Preferences

    #442

    Anchors are a way we can refer to the absolute positioning of a view at any level in the view tree. This is useful when you want to have one view surround, underline, or point to another element in the view tree. Combined with GeometryReader, you don't need to worry about converting between coordinate systems like you do in UIKit. Anchors work much like other preferences, with some small differences. In this episode we will build a bar graph view, then use anchors to animate an indicator on the selected item in the graph.

  • Paging Between Views with SwiftUI

    #441

    Paging between views is something that is not yet provided by SwiftUI, but we can lean on UIViewControllerRepresentable to borrow this behavior from UIKit. Doing so we'll learn about the Coordinator design for handling events via delegates and datasources. We'll also see some of the rough edges you might run into when using this technique.