Tag Archive for: WWDC23

Mergeable libraries are a new feature in Swift that allow you to merge multiple libraries into a single binary. This can improve the performance of your app by reducing the number of files that need to be loaded at runtime. In addition, mergeable libraries are also smaller than individual libraries, which can save space on disk and in memory.

New library type: Mergeable library

If you’ve written multi-architecture code or open source code before, you know that Apple had two types of libraries, static and dynamic. We now have 3 library types along with the combinable library type. As much as possible, the new library type is focused on solving the problems of static and dynamic libraries. While solving these problems and disadvantages, it promises many advantages and also solves the complexity of multiple architectures. Let’s examine together what this library, which Apple introduced at this year’s WWDC23, provides us.

Advantages

Mergeable library brings together the static or dynamic libraries you have created before and presents them to you under a single roof. In doing so, it does not cost you extra. Here are some advantages of the mergeable library;

• Mergeable libraries can reduce the size of your apps by up to %50.
• Mergeable libraries can improve the launch time of your apps by up to %20.
• Mergeable libraries can make your apps more reliable by reducing the number of crashes.
• Mergeable libraries make it easier to manage your dependencies, as you can update them all at once.
• Mergeable libraries can improve the security of your app by reducing the number of potential attack vectors.

Using Mergeable Libraries to Improve Your Apps

To use mergeable libraries, you need to add the MERGED_BINARY_TYPE build setting to your app target and set it to automatic. You also need to add the MERGEABLE_LIBRARY build setting to each library that you want to merge. If you have any problems with mergeable libraries, you can disable them by removing the OTHER_SWIFT_FLAGS flag from your project’s build settings.

Once you have configured your project for mergeable libraries, Xcode will automatically merge all of your direct dependencies into a single binary. This will improve the performance and reduce the size of your app.

Mergeable libraries are a new feature in Swift that can be used to improve the performance, size, and security of your app. If you are looking to improve the performance, size, and security of your Swift app, then you should consider using mergeable libraries.

I hope this article has helped you to understand the benefits of mergeable libraries and how to use them to improve the performance and reliability of your apps. If you are a developer who is interested in improving the performance and reliability of your apps, I encourage you to check out the WWDC 2023 Meet Mergeable Libraries session.

Apple has indeed emphasized the integration of SwiftUI with other APIs and frameworks during WWDC23, and SwiftData is one of the examples. SwiftUI and Macros work together seamlessly in perfect harmony. SwiftData is also compatible with CloudKit and Widgets. Now, let’s explore the @Model macro, one of Swift’s new macros, and quickly delve into how SwiftData facilitates reading and editing data.

Lets Explore @Model Makro

Unlike CoreData, SwiftData allows you to stay within the Swift ecosystem. Your models are constructed entirely using Swift code, and with a single macro, they are transformed into robust objects that seamlessly integrate with SwiftData. This approach ensures that you can fully leverage the power of Swift while working with data models in SwiftData. In this way, we do not need CoreData’s UI for the data model and then the Swift class we created to use the model.

For example, you can establish a relationship between two objects or specify them to be unique with the attribute property.

This makes it very convenient for us to create relational data and keep it locally on our device without an extra library. Now there are two key objects we need to know in order to use these models.

ModelContainer and ModelContext

ModelContainer provides you persistent backend. You can prepare your container by default or with many customization options, including CloudKit.

You can also define it directly for use in SwiftUI.

ModelContext, on the other hand, is an interface that tracks all the actions that take place in the models we set up in the context and enables us to take action. In SwiftUI you usually access it as follows.

We are now ready to access our data when we have done all this. Because SwiftData uses macros, it also uses the new #Predicate with iOS 17. This is an incredibly practical layout with macros that replaces the old layout type-controlled NSPredicate.

Meet #Predicate & Fetch some Data

A simple predicate can be created with only one line with these macros. This is pretty awesome because the code we write is pretty minimal.

Of course, a predicate must be able to control more than one thing, which can be combined with conditions.

To fetch data using predicates and in a specific order, we can utilize the SortDescriptor property in SwiftData. By mapping the SortDescriptor property to a property of our model, we can incorporate it into the fetch operation. This allows us to fetch the desired data while maintaining the desired order.

In addition, you can use FetchDescription to limit the number of results, check if the data has been recorded before, and much more.

SwiftUI and SwiftData: Rush Binary

SwiftData was developed with SwiftUI in mind, seamlessly integrating, and enabling powerful operations. The operations that can be performed using the existing context are incredibly straightforward, reminding us that we are genuinely writing Swift code.

After installing ModelContainer and ModelContext, SwiftUI gives you complete control. For example, you can print the data in order in a few seconds using @Query.

Remember, with Observation, you don’t need wrappers like @Published. SwiftUI does this for you. If you’re interested in how SwiftUI does it, you can check it out here.

Summary

In this article, we met with SwiftData and witnessed what it can do using the combination of SwiftUI & Macro.

Also, you can watch this session here. Enjoyable and Swiftyyy coding 🧡

One of the tough challenges for developers is teaching how to use the app to the user. It is so important because it relates to the purchase rate. Only the users who know how to use the app purchases a subscription. We call onboarding this teaching process.

Onboarding includes two steps most of the time. The first step is the classic sliding pages between 2-5 that introduce the app roughly. The second step is introducing how UX elements (button, label, switch, etc.) work on specific screens. TipKit is one of the new features which is announced at WWDC23 is about the second step.

It helps to teach the user how to use the app by introducing the view components. The main job of TipKit is to highlight a particular view to show what the user should focus on.

Excluding TipKit, developers use third-party alternatives such as Instructions. TipKit will be the native solution with iOS 17 now.

One of the best uses of TipKit is increasing feature discoverability. Imagine that the new version of the app has a new feature triggered by a button. All the developer needs to do is highlight the button with a short feature description through TipKit. The user easily notices the button and new feature.

It is also available on iPadOS, macOS, watchOS, and tvOS.

Make It Live

The start point is calling the configure method of TipsCenter at the app launch.

All you need to do is to create a struct and conform to Tip protocol. It brings title, message, and asset properties to configure the view.

Title: the first biggest text

Message: the second detailed text

Asset: the helper image of the tip

You also can add actions and listen them by the id property.

Afterward, you are supposed to call popoverMiniTip to show the tip view.

The tip view will be shown when the star button is tapped.

You can also set some rules, such as show the tip only if the user is logged in.

Tip options can be set by calling options property. You can set max display count easily.

TipsCenter

It is the singleton object to manage all tips. You can show all or some specific tips by calling the related functions in TipsCenter.

Recommended Uses

These are the recommended usage examples by Apple. They are supposed to be easy to read and remember. Long sentences are not recommended.

Non-Recommended Uses

These are the non-recommended ones. Tips should be used to educate users. They are not toast messages.

Summary

We, as developers, always struggle to tell the users some of the app’s primary functions. Before TipKit, our choice would be third-party libraries. By TipKit, we would be happy to use the native solution and teach the primary features/actions to the users quickly.

You can watch the WWDC session of TipKit here.

To stay updated with upcoming posts about Apple sessions, be sure to subscribe to our newsletter below.

See you in our next article!

As in every year, Apple announced some of its new products and technologies for both users and developers at the WWDC23 conference. In this article, we will take a quick look at Xcode15 and the innovations it offers.

Quick Look to Xcode 15

Discover the latest productivity and performance improvements in Xcode 15. Explore enhancements to code completion and Xcode Previews, learn about the test navigator and test report, and find out more about the streamlined distribution process. We’ll also highlight improved navigation, source control management, and debugging.

Ready, set, code

Get ready to code with ease. Xcode 15 is now available on the Mac App Store and comes with a 50% reduction in size. It offers downloadable simulator runtimes for all platforms, allowing you to test your apps seamlessly. Experience enhanced code completion, which not only assists you in writing safer code but also references all your assets. With improvements in the compiler and a newly optimized linker designed for Apple silicon’s multicore architecture, projects build faster than ever before.

The Best Way to Stay in Control: Stay Organized

Xcode 15 introduces powerful tools for improved organization and simplified localization. The Bookmark Navigator allows you to track important code landmarks and manage tasks effortlessly. The new String Catalog centralizes localization assets for easy review and updates. Additionally, Xcode 15 enhances documentation with a beautiful design and real-time preview. Experience enhanced organization, streamlined localization, and captivating documentation in Xcode 15.

Swift and SwiftUI: Unifying the Development Experience

Swift, SwiftUI, and Xcode 15 come together harmoniously, offering a unified development experience. Thanks to the new Swift macros, Xcode Previews have become even more user-friendly, now compatible with SwiftUI, UIKit, and AppKit. The introduction of an interactive timeline aids in the development and design of widgets. Additionally, working with multiple platforms and devices has never been easier – simply select them directly in the preview canvas to ensure your views look exceptional across all platforms.

Beyond Debugging

Unlock the full potential of macros in the source editor, empowering you to set breakpoints and seamlessly step into the generated code. With ease, access and analyze debug output using the structured console. Maximize your debugging capabilities and streamline your development process with these powerful features.

Summary

As with every year, Apple unveiled its new technologies and some of its new products at the WWDC23 conference. One of these innovations is Xcode 15, which brings several advancements. Xcode 15 is 50% smaller, 100% faster, and, as always, designed to make developers’ lives easier and more efficient.

To stay updated with upcoming posts about Apple sessions, be sure to subscribe to our newsletter below.

See you in our next article!

The swift version I will be talking about is 5.9. As every year, Apple continues to develop the Swift language this year. And Swift is stronger and more performant this year, just like every year. Below I will talk about the striking features of the new version of Swift with examples. Let’s start.

if and switch Expressions (SE-0380)

This feature introduces the ability to use if and switch statements as expressions, for the purpose of:

• Returning values from functions, properties, and closures (either implicit or explicit)
• Assigning values to variables
• Declaring variables

For an if or switch to be used as an expression, it would need to meet these criteria:

• Each branch of the if, or each case of the switch, must be a single expression.
• Each of those expressions, when type checked independently, must produce the same type.
• In the case of if statements, the branches must include an else.

Generic improvement

Type inference makes APIs using parameter packs natural to use, without needing to know that the API is using them, i.e call-side might not even aware you are using type parameter pack under the hood.

Enabling generic abstraction over argument length <each Result> know as type parameter pack (multiple individual type parameters that are “packed” together)

Convenience AsyncStream.makeStream methods (SE-0388)

This feature adds a new static method makeStream on AsyncStream and AsyncThrowingStream that returns both the stream and the continuation, which make the stream’s continuation easier to access.

Custom Actor Executors (SE-0392)

This proposal proposes a way to customize the executors of actors in Swift, which are responsible for scheduling and running tasks on actors. Executors are abstract types that conform to the Executor protocol and provide a enqueue(_:) method to submit tasks to be executed.

This proposal also defines a SerialExecutor protocol, which is what actors use to guarantee their serial execution of tasks (jobs).

All actors implicitly conform to the Actor (or DistributedActor) protocols. Those protocols include the customization point for the executor they are required to run on in form of the the unownedExecutor property.

Add sleep(for:) to Clock (SE-0374)

There is currently a slight imbalance between the sleep APIs for clocks and tasks, and it causes some troubles when dealing with Clock existentials.

This release introduce a sleep(for:) method that only dealt with durations, and not instants, then we could invoke that API on an existential:

C++ Interoperability

We used to implement Swift ↔ Objective-C ↔ C++ to use C++ language. Swift now has direct access to C++. In this way, we will be able to benefit from the power of the C++ language more easily and quickly.

Its use is as simple as shown below!

Yes, that’s how some standout headers were in Swift. Swift has many more improvements. To see more details, you can watch the session video or read the swift-evoulation document.

To stay updated with upcoming posts about Apple sessions, be sure to subscribe to our newsletter below.

See you in our next article!