https://cocoacasts.com If you're looking for a quick fix, then I don't have anything to offer you. If you want to become a better Swift developer, then have a seat and let me share with you what I know. en-us Tue, 25 Jan 2022 16:41:25 +0000 Tue, 25 Jan 2022 16:41:25 +0000 40 In the previous episodes, we added support for fetching, creating, and updating video progress. In this episode, you learn how to delete the progress for a video, the D in CRUD. Deleting the progress for a video is a bit special because the body of the response is empty. Let me show you what changes we need to make to add support for deleting the progress for a video. Tue, 18 Jan 2022 06:30:00 +0000 https://cocoacasts.com/building-a-modern-networking-layer-in-swift-deleting-video-progress https://cocoacasts.com/building-a-modern-networking-layer-in-swift-deleting-video-progress In the previous episode, you learned about CRUD operations and we applied this to video progress. We added the ability to fetch the progress for a video, the R in CRUD. In this episode, we cover creating and updating video progress, the C and U in CRUD. Tue, 11 Jan 2022 06:30:00 +0000 https://cocoacasts.com/building-a-modern-networking-layer-in-swift-creating-and-updating-video-progress https://cocoacasts.com/building-a-modern-networking-layer-in-swift-creating-and-updating-video-progress At this point, you should have a good understanding of the networking layer we are building. Even though we have written quite a bit of code, the networking layer we built isn't complex. We simply combined a number of common patterns and techniques to create a solution that is easy to use and extend. Later in this series, I show you that it is also easy to test. Tue, 21 Dec 2021 06:30:00 +0000 https://cocoacasts.com/building-a-modern-networking-layer-in-swift-fetching-video-progress https://cocoacasts.com/building-a-modern-networking-layer-in-swift-fetching-video-progress The video view model is no longer required to pass an access token to the API client if it requests the video of an episode. That is a welcome improvement. The API client passes an access token to an APIEndpoint object and it is the APIEndpoint object that decides when it is appropriate to add an Authorization header to a request. The changes we made in the previous episode improved the networking layer we are building. Tue, 14 Dec 2021 06:30:00 +0000 https://cocoacasts.com/building-a-modern-networking-layer-in-swift-hiding-implementation-details-with-type-erasure https://cocoacasts.com/building-a-modern-networking-layer-in-swift-hiding-implementation-details-with-type-erasure In the previous episode, we extended the API client with the ability to fetch the video for an episode. Because videos are protected resources, the request includes an Authorization header with an access token as its value. The solution we implemented works, but it is tedious to pass the access token to the API client and the object invoking the video(id:accessToken:) method shouldn't need to deal with access tokens. That is a responsibility of the API client. Tue, 7 Dec 2021 06:30:00 +0000 https://cocoacasts.com/building-a-modern-networking-layer-in-swift-injecting-the-access-token https://cocoacasts.com/building-a-modern-networking-layer-in-swift-injecting-the-access-token In this and the next episodes, we add the ability for the user to watch an episode. For that to work, the application needs to fetch the video for the episode from the mock API. Fetching a video is similar to fetching the list of episodes. The difference is that the user needs to be signed in to fetch a video because a video is a protected resource. The request to the /videos/:id endpoint needs to include an Authorization header. The value of the Authorization header is the access token the application receives after successfully signing in. Tue, 23 Nov 2021 06:30:00 +0000 https://cocoacasts.com/building-a-modern-networking-layer-in-swift-working-with-protected-resources https://cocoacasts.com/building-a-modern-networking-layer-in-swift-working-with-protected-resources Earlier in this series, we declared the computed message property in the APIError enum. While that seemed like a good idea at that time, the previous episode showed that we need a solution that is more flexible. The APIError enum doesn't have the context it needs to define a human-readable message for each of its cases. Tue, 16 Nov 2021 06:30:00 +0000 https://cocoacasts.com/building-a-modern-networking-layer-in-swift-better-error-handling https://cocoacasts.com/building-a-modern-networking-layer-in-swift-better-error-handling The user needs to be signed in to watch a video so the next feature we implement is the ability for the user to sign in with their email and password. This episode illustrates how a proper foundation can save time and reduce complexity. The improvements we made in the previous episode simplify the changes we need to make in this and the next episodes. Tue, 9 Nov 2021 06:30:00 +0000 https://cocoacasts.com/building-a-modern-networking-layer-in-swift-authenticating-the-user https://cocoacasts.com/building-a-modern-networking-layer-in-swift-authenticating-the-user Because the application will interface with a number of endpoints of the mock API, we need to make sure the API client is easy to extend. The more we can reduce code duplication, the easier it is to extend and maintain the API client. In this episode, I show you how to use generics to make the API client extensible and easy to maintain. Tue, 2 Nov 2021 06:30:00 +0000 https://cocoacasts.com/building-a-modern-networking-layer-in-swift-making-the-api-client-extensible https://cocoacasts.com/building-a-modern-networking-layer-in-swift-making-the-api-client-extensible Even though there is nothing inherently wrong with a view model performing network requests, it isn't an approach I recommend. Moving the networking logic out of the view model has a number of benefits. It reduces code duplication, facilitates unit testing, and improves the maintainability of the project to name a few. Mon, 25 Oct 2021 06:30:00 +0000 https://cocoacasts.com/building-a-modern-networking-layer-in-swift-creating-an-api-client https://cocoacasts.com/building-a-modern-networking-layer-in-swift-creating-an-api-client Handling errors is one of the less enjoyable aspects of software development, but it is an important one. You don't want to show the user a cryptic error message when something goes wrong, or worse, no error message. There is no clear-cut recipe you can follow. Every project is different. The good news is that error handling is built into Swift and the Combine framework. Let me show you how we can improve the code we wrote in the previous episode. Fri, 22 Oct 2021 06:30:00 +0000 https://cocoacasts.com/building-a-modern-networking-layer-in-swift-handling-errors https://cocoacasts.com/building-a-modern-networking-layer-in-swift-handling-errors We start this series by making a simple GET request to the mock API to fetch the list of episodes. We won't be using a third party library. One of the goals of this series is to show you how to build a modern networking layer that relies on Foundation's URLSession API. It is simpler than you might think. Wed, 20 Oct 2021 06:30:00 +0000 https://cocoacasts.com/building-a-modern-networking-layer-in-swift-fetching-a-list-of-episodes https://cocoacasts.com/building-a-modern-networking-layer-in-swift-fetching-a-list-of-episodes In this series, you build a modern networking layer for a Swift application using Foundation's URLSession API. We cover a range of topics, basic and more advanced, from making a simple GET request to signing requests with an access token. We make use of generics and protocol-oriented programming to create a networking layer that is flexible, testable, and easy to extend. Mon, 18 Oct 2021 06:30:00 +0000 https://cocoacasts.com/building-a-modern-networking-layer-in-swift-exploring-the-api https://cocoacasts.com/building-a-modern-networking-layer-in-swift-exploring-the-api With the view and the view model in place, we can authenticate the user. In this episode, you learn how to authenticate a user using the URLSession API and basic authentication. Wed, 13 Oct 2021 06:30:00 +0000 https://cocoacasts.com/building-a-sign-in-form-using-swiftui-authenticating-the-user https://cocoacasts.com/building-a-sign-in-form-using-swiftui-authenticating-the-user In the previous episode, we built a sign in form using SwiftUI. In this episode, we create and integrate a view model that drives the sign in form. Tue, 12 Oct 2021 06:30:00 +0000 https://cocoacasts.com/building-a-sign-in-form-using-swiftui-adopting-the-model-view-viewmodel-pattern https://cocoacasts.com/building-a-sign-in-form-using-swiftui-adopting-the-model-view-viewmodel-pattern In this series, we build a sign in form using SwiftUI. In the first episode, we build the user interface. In the next episodes, we apply the model-view-viewmodel pattern and perform a network request to sign the user in. At the end of this series, we have a fully functional sign in form that is ready to be integrated into an application. Mon, 11 Oct 2021 06:30:00 +0000 https://cocoacasts.com/building-a-sign-in-form-using-swiftui-building-the-user-interface https://cocoacasts.com/building-a-sign-in-form-using-swiftui-building-the-user-interface A few years ago, Apple added a number of APIs to the Foundation framework to make it easier to work with units and measurements. The APIs are flexible and straightforward to use. As of this year, SwiftUI integrates with these APIs to make it trivial to display units and measurements. The SwiftUI APIs we discuss in this episode are available as of iOS 15, tvOS 15, macOS 12, and watchOS 8. Wed, 6 Oct 2021 06:30:00 +0000 https://cocoacasts.com/swiftui-essentials-working-with-units-and-measurements-in-swiftui https://cocoacasts.com/swiftui-essentials-working-with-units-and-measurements-in-swiftui To customize a view in a UIKit or AppKit application, you update one or more of the view's properties. For example, to change the text color of a UILabel instance, you update the label's textColor property. That is an imperative approach to user interface development. Wed, 28 Jul 2021 04:30:00 +0000 https://cocoacasts.com/swiftui-fundamentals-customizing-views-with-modifiers https://cocoacasts.com/swiftui-fundamentals-customizing-views-with-modifiers SwiftUI's declarative syntax makes it straightforward to describe the user interface you have in mind. The API is intuitive and the framework's learning curve is gentle. But Apple didn't stop there. SwiftUI is deeply integrated into Xcode, making it almost trivial to build user interfaces using SwiftUI. Wed, 21 Jul 2021 04:30:00 +0000 https://cocoacasts.com/swiftui-fundamentals-working-with-xcode-previews https://cocoacasts.com/swiftui-fundamentals-working-with-xcode-previews A view is the fundamental building block of your application's user interface. You already know that a view is a type that conforms to the View protocol. In this episode, we take a closer look at views and the View protocol. Wed, 14 Jul 2021 04:30:00 +0000 https://cocoacasts.com/swiftui-fundamentals-what-is-a-view https://cocoacasts.com/swiftui-fundamentals-what-is-a-view While it is possible to integrate SwiftUI into a UIKit or AppKit application, this series focuses on building applications that are built entirely using SwiftUI. Wed, 7 Jul 2021 04:30:00 +0000 https://cocoacasts.com/swiftui-fundamentals-exploring-a-swiftui-application https://cocoacasts.com/swiftui-fundamentals-exploring-a-swiftui-application SwiftUI is Apple's brand new framework for building user interfaces for iOS, tvOS, macOS, and watchOS. Apple introduced SwiftUI in 2019 and the framework has been evolving at a rapid pace ever since. Unlike UIKit and AppKit, SwiftUI is a cross-platform framework. With SwiftUI, Apple offers developers a solution for rapidly building applications. In this series, you learn everything you need to build applications using SwiftUI. Wed, 30 Jun 2021 04:30:00 +0000 https://cocoacasts.com/swiftui-fundamentals-what-is-swiftui https://cocoacasts.com/swiftui-fundamentals-what-is-swiftui The API the image service exposes no longer accepts a completion handler. It returns a publisher instead. This is an improvement, but the image service still uses completion handlers under the hood. In this episode, we replace the completion handlers the image service uses internally with publishers. Wed, 23 Jun 2021 04:30:00 +0000 https://cocoacasts.com/building-reactive-applications-with-combine-transforming-publishers-with-flat-map https://cocoacasts.com/building-reactive-applications-with-combine-transforming-publishers-with-flat-map In the previous episode, you learned about futures and promises. In this episode, I show you how to use them in a project. Wed, 16 Jun 2021 04:30:00 +0000 https://cocoacasts.com/building-reactive-applications-with-combine-replacing-completion-handlers-with-futures https://cocoacasts.com/building-reactive-applications-with-combine-replacing-completion-handlers-with-futures Earlier in this series, you learned how a subject can bridge the gap between imperative programming and reactive programming. While subjects are convenient in many ways, they are not always the best option. The Combine framework provides another option. In this episode, we zoom in on futures and promises to bridge the gap between imperative programming and reactive programming. Wed, 9 Jun 2021 04:30:00 +0000 https://cocoacasts.com/building-reactive-applications-with-combine-futures-and-promises https://cocoacasts.com/building-reactive-applications-with-combine-futures-and-promises The first application I published on the App Store was littered with code smells, bad practices, and anti-patterns. The application worked, but it was a challenge to maintain. Adding features to a large, complex project becomes increasingly difficult if it lacks direction and structure. Wed, 2 Jun 2021 04:30:00 +0000 https://cocoacasts.com/five-signs-of-code-smell-in-swift https://cocoacasts.com/five-signs-of-code-smell-in-swift Infinite loops are every developer's nightmare, especially if they have disastrous consequences. You need to be mindful of infinite loops when working with Combine or any other reactive framework. The difficulty is that it isn't always obvious that you created an infinite loop. As a matter of fact, we introduced an infinite loop earlier in this series. You receive a bonus point if you can spot it. Wed, 26 May 2021 04:30:00 +0000 https://cocoacasts.com/building-reactive-applications-with-combine-avoiding-infinite-loops https://cocoacasts.com/building-reactive-applications-with-combine-avoiding-infinite-loops To be productive and efficient, you need to know your tools. For a Swift developer, that means mastering Xcode. While Xcode is a complex piece of software with a fairly steep learning curve, the tricks I show you in this episode should significantly boost your productivity. Wed, 19 May 2021 04:30:00 +0000 https://cocoacasts.com/seven-xcode-tricks-every-developer-should-know https://cocoacasts.com/seven-xcode-tricks-every-developer-should-know In the previous episodes, we implemented a service to fetch and cache remote images. Even though the service we built is pretty flexible, some applications require a more powerful solution and more options to fit their needs. This episode focuses on Kingfisher, a popular, open source library to fetch and cache remote images. You learn how to integrate Kingfisher in a project using CocoaPods. I show you how Kingfisher differs from the service we created earlier in this series and we take a peek under the hood to learn how Kingfisher does its magic. Wed, 12 May 2021 04:30:00 +0000 https://cocoacasts.com/image-caching-in-swift-image-caching-with-kingfisher https://cocoacasts.com/image-caching-in-swift-image-caching-with-kingfisher Earlier in this series, you learned that a cache on disk has a number of benefits. It persists the cache across launches and it can be used to seed a cache in memory. Even though modern devices have plenty of disk space, we need to be mindful of the space the cache on disk takes up on the user's device. Applications like Twitter and Instagram fetch hundreds if not thousands of images. Even if those images are optimized and small in size, the cache on disk can grow quickly, taking up a non-trivial amount of space on the user's device. In this episode, we add the ability to limit the size of the cache on disk, similar to how the image service limits the size of the cache in memory. Wed, 5 May 2021 04:30:00 +0000 https://cocoacasts.com/image-caching-in-swift-limiting-the-cache-on-disk https://cocoacasts.com/image-caching-in-swift-limiting-the-cache-on-disk The previous episodes have illustrated that caching images can result in significant performance improvements. In the previous episode, I stressed the importance of writing cached images to disk on a background thread to prevent the image service from blocking the main thread. Wed, 28 Apr 2021 04:30:00 +0000 https://cocoacasts.com/image-caching-in-swift-asynchronously-reading-data-from-disk https://cocoacasts.com/image-caching-in-swift-asynchronously-reading-data-from-disk In this episode, we continue to improve the solution we implemented in this series by caching images on disk. Caching images on disk has a number of benefits. It reduces the number of requests the application makes and it improves the performance of the application. The user experiences the application as fast and snappy. Wed, 21 Apr 2021 04:30:00 +0000 https://cocoacasts.com/image-caching-in-swift-caching-images-on-disk https://cocoacasts.com/image-caching-in-swift-caching-images-on-disk We added the ability to cancel image requests in the previous episode. This and the next episode focus on caching images. We start simple by caching images in memory. Wed, 14 Apr 2021 04:30:00 +0000 https://cocoacasts.com/image-caching-in-swift-caching-images-in-memory https://cocoacasts.com/image-caching-in-swift-caching-images-in-memory Most applications display images in some way, shape, or form. Those images are often fetched from a remote server, introducing a number of interesting challenges. Performing a request to a remote server takes time and it requires resources. It is therefore important to consider solutions to minimize the number of requests an application makes. Wed, 7 Apr 2021 04:30:00 +0000 https://cocoacasts.com/image-caching-in-swift-cancelling-image-requests https://cocoacasts.com/image-caching-in-swift-cancelling-image-requests If you are new to Swift, then you may be wondering what a failable initializer is and why you would ever use one. In this episode, I show you how to create a failable initializer and I hope I can convince you of their benefits. I use failable initializers in every project I work on and you may be surprised when I say that you do too. Wed, 31 Mar 2021 04:30:00 +0000 https://cocoacasts.com/swift-patterns-failable-initializers https://cocoacasts.com/swift-patterns-failable-initializers Cloudy shows the user an error if it isn't able to fetch weather data from the weather API. We map any errors that are thrown to WeatherDataError in the RootViewModel class. This solution works fine and it is a fitting implementation for the weather application we are building. In this episode, I show you three other options to handle errors. Wed, 24 Mar 2021 05:30:00 +0000 https://cocoacasts.com/building-reactive-applications-with-combine-recovering-from-errors https://cocoacasts.com/building-reactive-applications-with-combine-recovering-from-errors Even though we successfully used the Combine framework to fetch data from the weather API, the implementation is incomplete. We ignored error handling up until now and it is time to take a closer look at errors and how to handle them. Wed, 17 Mar 2021 05:30:00 +0000 https://cocoacasts.com/building-reactive-applications-with-combine-handling-errors https://cocoacasts.com/building-reactive-applications-with-combine-handling-errors Earlier in this series, you learned that reactive programming can be defined as working with asynchronous streams of data. A network request is an asynchronous operation and that makes reactive programming an excellent match for networking. Wed, 10 Mar 2021 05:30:00 +0000 https://cocoacasts.com/building-reactive-applications-with-combine-networking-and-schedulers https://cocoacasts.com/building-reactive-applications-with-combine-networking-and-schedulers The interface of the UserDefaults class is easy to use, but it lacks type safety. If you want to store and retrieve an enum, for example, you need to jump through a few hoops. Let me show you an example from Cloudy, the application we build in Mastering MVVM With Swift. Wed, 3 Mar 2021 05:30:00 +0000 https://cocoacasts.com/use-extensions-to-add-type-safety-to-user-defaults https://cocoacasts.com/use-extensions-to-add-type-safety-to-user-defaults The builder pattern isn't a common pattern in Swift and Cocoa development and you don't find it in any of Apple's frameworks. It is one of the Gang of Four design patterns and widely used in Java development. Wed, 24 Feb 2021 05:30:00 +0000 https://cocoacasts.com/swift-patterns-builders https://cocoacasts.com/swift-patterns-builders