Sunday, July 21, 2024

Latest Posts

WWDC 2024 Recap | Kodeco


WWDC 2024 has come and gone, which appears to occur faster and faster annually, and in its wake are a number of movies to take a look at. There have been so many movies this 12 months, Apple began releasing them Monday night time after the Platform State of the Union, so that you knew it was going to be a packed week. It could be inconceivable to cowl all the brand new materials in a single article. Nevertheless, between the Keynote, the Platform State of the Union, and a few choose movies, listed here are some stuff you undoubtedly want to take a look at. These are in no specific order, however all are must-watches if you happen to’re an Apple developer.

Swift

Swift 6 is the large change this 12 months, though you’ll be able to fortunately undertake the brand new secure data-race security conformance at your individual tempo, module by module, because of compiler’s Swift 6 language mode choices. Along with utilizing Swift on embedded units, improved C++ interoperability, and non-copyable varieties, two actually cool objects stood out.

Absolutely Static Linux SDK for Swift

Now you can cross-compile your apps for Swift on Linux and embody the Swift libraries as a completely static part of your app. This implies the vacation spot doesn’t have to have Swift put in. This may be nice for deploying issues like internet service apps over to a Linux system.

Typed Throws

Now you can used typed throws to get higher suggestions on precisely what error is caught. For instance:

enum MyError: Error {
    misTyped, whatWasIThinking
}

func foo(string: String) throws(MyError) -> String {
    //.....
    throw MyError.misTyped(string)
}

do {
    let response = attempt foo(string: "Hiya world!")
} catch {
    //the error right here is of kind "MyError" as a substitute of simply "Error"
}

For extra on Swift this 12 months, make sure to try What’s new in Swift, and for extra on migrating your undertaking to Swift 6, try Migrate your app to Swift 6

SwiftUI

SwiftUI received a good variety of updates this 12 months, as regular. Listed below are among the issues that stood out.

View Is now on the @MainActor

You not have to mark your views with @MainActor as a result of the View protocol now has that ornament. That’s one much less line of code to write down!

The Magic Floating Tab Bar (or Is it a Sidebar?)

One thing that’s already getting a blended response is the brand new tab view type:

struct TabBarExample: View {
    var physique: some View {
        TabView {
            Textual content("Tab 1")
                .tabItem {
                        VStack {
                        Picture(systemName: "1.circle")
                        Textual content("Tab 1")
                    }
                }
            Textual content("Tab 2")
                .tabItem {
                        VStack {
                        Picture(systemName: "2.circle")
                        Textual content("Tab 2")
                    }
                }
            Textual content("Tab 3")
                .tabItem {
                        VStack {
                        Picture(systemName: "3.circle")
                        Textual content("Tab 3")
                    }
                }
        }
        .tabViewStyle(.sidebarAdaptable)
    }
}

This can lead to certainly one of two photos, relying on whether or not you desire a floating tab bar on the prime (assume visionOS) or a standard sidebar (assume NavigationSplitView):

Floating tab bar at top

Traditional sidebar

I haven’t had an opportunity to play quite a bit with this one, however as with all paradigm-breaking issues, there’s often a little bit of disagreement in the neighborhood about it. We’ll see how this one shakes out!

New Modifiers for Presentation and Zooming

For views represented in a sheet, a brand new modifier permits you to specify web page, type, or customized sizing:

    .presentationSizing(.type)

And to get a pleasant zoom in animation when bringing views to the foreground, a brand new pair of modifiers might help you:

.navigationTransition(.zoom(
                    sourceID: merchandise.id, in: namespace))
                    
///....

.matchedTransitionSource(id: merchandise.id, in: namespace)
}


For extra on SwiftUI this 12 months, make sure to try What’s new in SwiftUI.

SwiftData

SwiftData didn’t have an enormous replace this 12 months like some have been hoping, but it surely did get some very needed updates to assist with efficiency and queries. This 12 months, Apple added the power to specify distinctive constraints with the #Distinctive macro and generally listed fields with Index. With only a few strains of code, you’ll be able to add these options to an current @Mannequin:

import SwiftData
import Basis

@Mannequin
class KodecoArticle {
    
    #Distinctive([.name, .dateWritten, .author])
    #Index([.name], [.dateWritten], [.author], [.name, .dateWritten, .author])
    
    var identify: String = ""
    var creator: String = ""
    var content material: String = ""
    var dateWritten: Date?
    var dateUpdated: Date?
    
    init(identify: String, creator: String, content material: String, dateWritten: Date? = nil, dateUpdated: Date? = nil) {
        self.identify = identify
        self.creator = creator
        self.content material = content material
        self.dateWritten = dateWritten
        self.dateUpdated = dateUpdated
    }
    
}

The #Distinctive line states that entries are distinctive on that mixture of properties, and the #Index line lists which properties, or mixture of properties, are added as additional metadata to the mannequin so it might probably carry out quicker queries.

Apple additionally unveiled different new options for SwiftData, akin to utilizing your individual customized knowledge retailer! For extra, try What’s New in SwiftData.

Frameworks That Are In all places

There have been two robust examples of frameworks that have been gaining parity and energy over many if not the entire platforms Apple offers. There’s quite a bit to cowl right here, so right here they’re together with hyperlinks to the WWDC movies.

App Intents

Over the previous few years, App Intents has change into a significant participant with regards to surfacing your app’s options; whether or not or not it’s to shortcuts, Siri, or widgets.

This 12 months, App Intents will get one other improve as a result of it’s the mechanism to hook your app into Apple Intelligence. For extra, make sure to try What’s new in App Intents, Deliver your app’s core options to customers with App Intents, and Deliver your app to Siri.

RealityKit

Through the years, RealityKit hasn’t been very uniform throughout the platforms, making it laborious to deploy the identical app to completely different Apple {hardware}. That modifications this 12 months, as RealityKit has a number of new cross-platform APIs throughout all the assorted platforms — visionOS, macOS, iOS, and iPadOS. For extra, try Uncover RealityKit APIs for iOS, macOS, and visionOS.

Swift Testing

Along with shifting the open supply Swift elements to the swiftlang group at GitHub, Apple has formally included Swift Testing in that household of libraries. Swift Testing is a brand new method of testing in Swift (however complementary to XCTest), introducing extra “Swifty” syntax to your take a look at code. Right here’s a fast instance:

import Testing

struct WWDCTests {

    @Take a look at func testExample() async throws {
        let worth = 2
        #anticipate(worth + worth == 3)
        
        let value2: Int? = nil
        _ = attempt #require(value2)
    }

}

After importing the Testing framework, you beautify your assessments with the @Take a look at attribute. This implies you not want to call your take a look at strategies so they begin with “take a look at”. I’ve added a couple of issues to check. The primary makes use of the #anticipate macro, which replaces the household of XCTAssert calls and checks to see whether or not the situation inside is true. The following code block checks that value2 just isn’t nil earlier than continuing through the use of the #require macro. See what Xcode says when the take a look at button is clicked:

Test results

In the correct gutter, you see indications that the expectations failed. For the primary one, if you happen to hover over the error, a “Present” button seems you could click on to get extra particulars, as proven within the screenshot. This allows you to dive into why precisely the examined code failed.

This seems to be to be quite a bit cleaner than XCTest (though you should use each in your assessments!), and I can’t wait to begin utilizing it. For extra about Swift Testing, try Meet Swift Testing.

Latest Posts

Stay in touch

To be updated with all the latest news, offers and special announcements.