Видео

Thank you! Perhaps my main advice is to try different formats (textbooks, RUclips videos, etc.) before committing to a 500-page book or an expensive online course. For instance, I choose hands-on projects because I can take different routes and experiment beyond the given task, keeping myself focused and entertained. On the other hand, practical projects don’t always go smoothly (you have to investigate and solve unforeseen problems by yourself), which can demotivate those who prefer comprehensive guidance. So try a few things first and then see what works best for you. I don’t believe you need a “special talent” to learn programming-but wrong tools can make this experience miserable.

I wouldn’t say we’re _proxying_ the production code in tests; more like defining the constraints it has to fit into, without recreating (or even knowing about) the implementation. In Swift Testing, it’s no different from the usual way we write tests. Typically, the body of a single test consists of four parts: 1. Define an input (which we control); 2. Define the expected result (which we know is correct); 3. Call the production code (which we’re not sure works correctly) on our input and get the actual result; 4. Make sure the actual result matches our expectations. We often need to check the same production code on different inputs, for which there’s a number of techniques: duplicating test methods (which is error-prone and tedious to update but gives you good visibility of which scenarios fail), using a for-in loop to iterate over different inputs within a single test (which requires less duplication but makes finding errors more difficult), etc. Parameterized testing solves this specific problem, without reinventing the fundamental approach to testing. It’s basically syntactic sugar to duplicate tests without you copying and pasting them manually. Test arguments move the inputs and expectations out of the test body, but you _still_ have two more tasks to do: call the production code and compare the results. That’s what the test body is for. In the demo, I don’t multiply anything _in the test code:_ The test knows _what_ the production code has to return, but doesn’t care _how_ it does it, so the production implementation doesn’t leak into tests. Not sure I 100% understood what you meant, so please correct me if I didn’t.

Я также проверил эту связку и не могу не подтвердить её эффективность.

Отлично, спасибо!

Sure, I’ll clarify. The purpose of this video is to highlight the updates you might’ve missed after the consumer stuff had stolen all the spotlight at the keynote. A new programming language and UI framework serve only as an illustration: Had Apple introduced something like that, it would’ve been _all_ people talk about (I witnessed the lines for SwiftUI sessions at WWDC19). The point I’m making in the video is, you shouldn’t overlook the other (exciting) updates simply because they’re not as groundbreaking as a new UI framework.

Thank you! Yep, the refreshed Air came out back in March: www.theverge.com/2024/3/4/24089999/apple-macbook-air-m3-announced-13-15-inch

Wow, seems like you’ve got a lot of experience to compare Swift to! Good luck with your console project!

Glad it was helpful!

Will do!

Thank you! Just trying to do my best here 🙌🏻

When you start writing a video, you never know how it’s gonna end 😂

Thank you for tuning in! 😄

Of course!

Thanks! What you want isn’t gonna be very easy because of two things. First, macros can’t change the existing code, so it’s not like you can swap the button’s action closure for the original action _plus your analytics code._ I thought of suggesting the good old property wrappers (which _can_ replace the original expressions), but then the second thing comes into play: SwiftUI buttons don’t expose their action closures. If this was a real task, not just an engineering exercise, I’d consider the least invasive approach: extending SwiftUI’s Button with an initializer which returns a normal Button, only with its handler updated to send the event. With something like init(_:event:action:), all you have to do is literally stick the event name in between the title and action.

Glad it was helpful!

Will do! Thanks!

Thanks! 🙌🏻 Actually, I often use the very same Medium posts for my research, adding just a couple things on top. I do some extra fact-checking (and even after that I don’t expect anyone to just trust my word, hence the links in the description). I try to present the data in a more visual format (although I still don’t have enough time to implement _all_ of my ideas). And then, I wrap everything in a cohesive narrative. The last part is probably the most important ingredient because (for me, at least) seeing the connections and big picture makes understanding stuff much easier (e.g. weak refs have certain properties for which the side table is needed, and the way the side table works calls for certain object-lifecycle steps). Like, everything affects everything, and I’m trying to untangle those connections 😄

Thank you so much 😍

Glad it was helpful!

Crashes of the build system itself? 🤔 Personally, one (big) issue I noticed after all the releases (and the video) is, Apple seems to have tweaked some checks on the App Store back end. I used to build my app with beta and RC versions of Xcode for the past few months, and they worked just fine in TestFlight. But a couple weeks ago, when I uploaded a fresh build created in the same environment, with very few changes in the project, that build was “processing” in ASC for, like, 12 hours-and then failed to deploy. Apple even reached out to me and showed some errors I’d never seen before: apparently, at least one Firebase component was “not a proper framework bundle.” I wouldn’t be surprised if that was the first time they saw this themselves. The funny thing is, I tried rebuilding and redeploying a commit that succeeded before, and got the same problem with infinite processing. Speaking of concurrency, I also noticed quite a few changes in the strict mode, but that project was small enough for me to fix them (except now I can’t go back to 15.2). So yeah, Xcode 15.3 does have its fair share of problems, after all 😵‍💫

@swiftbird so would you recommend downgrading to 15.2 then going back to 15.3 once they have addressed the bugs. Even when I start a new project the default “Hello World!” View will not preview or simulate

I think it could be something different in your case 🤔 Most of the issues I had were caused by third-party frameworks (e.g. Firebase) or App Store checks-neither are part of Xcode itself. Missing previews in SwiftUI happen from time to time, except they’re not really missing-it’s just the preview pane (“canvas”) decided to not show for some reason (but it can be re-enabled in editor options).

I guess KMM’s come a long way in the couple years I didn’t touch it! What do you think of debugging when it comes to the Swift / Kotlin joint? Back in 2021 everything felt very fragile, which only added to the confusion 😵‍💫

It is not apples wheel house so cannot see it happen. I suppose individuals or groups are free to develop their own service platform to use Swift.

Thank you! 🥹 I guess I’ll add a C++ interop section in an episode on using Swift outside Apple platforms. TBH, I’m hesitant to do a separate video about C++ because I wouldn’t call myself an expert here.

Thank you!

Hi! While the side table keeps track of the all three counts, it acts as a proxy _only_ for weak references. Unowned refs point directly to the object, not the side table. So as long as you have unowned references, you also need to have _something_ at their memory address.

Thank you! You raised a good point! Though very rarely, I certainly did receive questions about this “when _exactly_ is memory deallocated (immediately, on the next run-loop iteration, etc.)” thing. But TBH, I hate those nitpicky questions designed to trip you, because job interviews are not theory exams. While I can answer many questions like this, in response I normally ask when was the last time this info helped with a real task. And then I’m shamelessly relishing the look on their face and dead silence 🥲 On this channel, I’m trying to paint the coherent picture one can easily wrap their head around, not make a cheat sheet one has to simply remember 🙌🏻 Your point doesn’t become any less valid, though. I decided to omit this aspect from the _memory-management_ episodes because for something needed as rarely, I didn’t want to introduce the whole concept of the run loop. But I’ll definitely cover this aspect in the run-loop episode!

Thanks for the tip! 🔥 I heard about some AI tools for Swift, but so far they’ve seemed more like a proof of concept. As for the dependencies, I _think_ you can link them via command line when building, but to me it feels more cumbersome than having a Package file 🤔

Dziękuję!

Thank you so much!

I’m glad it was helpful!

Interesting comparison, thanks!

Thanks!

Totally agree with your point on game development! And I guess last year’s update that added explicit lifetime management could reduce ARC overhead and make Swift even more appealing for high-performance tasks. But my take on server and web development is slightly different. It’s overcrowded, true, but Swift doesn’t really need to defeat others to succeed. Things like WebAssembly are supposed to make the web and back end language-agnostic so what you use depends entirely on what you _want_ to use. The only problem with Swift is that its back-end community hasn’t yet reached the point of sustainability, where great projects attract new members who create even more great projects. Sort of a chicken-or-egg problem.

Hi! No, of course not. Minor Swift versions (5.8, 5.9, etc.) don’t remove any previously-added features, though they can change the way those features work. But normally, you can use everything from every previous release.

Sure! I sped up this clip so it fits RUclips’s one-minute limit. The full video (ruclips.net/video/UfvVVDBKPRs/видео.html) is much slower 🙌🏻

Thank you! 😍

Thank you for the kind words! ✨