This is still speculative tech, no?

I remember seeing a demo. It doesn’t honestly seem very hard.

I don’t think induction alone would cut it. Having the drone make contact and step down hundreds of kilovolts seem pretty hard to me. Plus the EM interference on the drones systems would be a challenge under the best circumstances.

I bet it won't by next month or so.

Most likely bystanders who got injured.

Knowing which parts of Foundation will explode on your face on Linux is most of the challenge of doing non-Apple Swift code.

None, if you stick to using the bits from swift-foundation instead of swift-corelibs-foundation. Confusing, but the new code is much better, and in production on Apple's platforms as well.

xibs were an absolute nightmare if you worked with a team. Even in the Objective-C days a lot of developers were sticking with programatic layout to avoid xibs. Google even had this mandated in their Objective-C style guide.

On iOS, code-only UIKit with bits of SwiftUI interspersed for simple components (think collection view cells) is definitely the way to go. UIKit is well equipped to be written that way (unlike Android Framework, which practically forces use of XML layouts in many cases).

For Mac dev, AppKit is still fairly heavily weighted towards use of XIBs, but it’s not nearly as much of an issue there because on average each individual XIB isn’t as overloaded with controls because the UI is more split up.

I’ve also had a good experience using SwiftUI with hosting confia for my cells. I am now at a point where I mostly use SwiftUI with just the occasional fallback to programmatic UIKit for the bits that are not quite there yet.

FWIW Android's XML layout is actually pleasant to use (though Jetpack Compose is also quite good).

My experience with Android XML is mixed, but that might actually be more of an Android Studio problem. I did enjoy being able to reasonably hand edit the files, which isn’t practical with XIBs, and so naturally git conflicts aren’t as hairy.

I definitely prefer Compose these days though.

Google's style guide is usually not a great reference if you want to write a language that they didn't make. But yes, XIBs kind of suck.

What’s that got to do with coherent language design? Just because it’s somewhat open doesn’t mean it has consistent design. Then by all accounts Apple just forced through language changes needed for SwiftUI.

I agree that that is the one counter example for the above. Apple forcing the closure syntax to better cater to SwiftUI left a sour taste in the mouths of an entire community.

Too many cooks!

And no Steve Jobs to pull them down to earth.

Steve Jobs, of course, was always involved in the details of programming languages targeting his platform.

He would probably raise hell about the state of the new macOS Setting window though. How this thing made it through QA remains a mystery.

He really was involved. As I understand it Obj-C was championed by him. NextSTEP was largely software related:

https://youtu.be/Hu-jvAWTZ9o?si=PalSP6POofiRuj3a

I still feel like GUI programming hasn’t progressed in the years since this. Actually they’ve regressed in many ways.

I wasn't there so I can't say for sure.

But my impression watching from the outside is that he had a finger in every pie.

Best designed? Really? Support for something as basic as consistent integer types across platforms is non-existent.

So following this same reasoning Python should become C?

I like how you think. I'm down for it. I have never liked dynamically typed languages.

In my experience, writing Swift for the backend feels a lot like writing TypeScript, but nicer — though that’s just a personal preference. You get the performance of a compiled language like Rust (though that’s rarely a bottleneck for backend applications), but Swift is significantly easier than Rust and has much faster compile times.

The second example is moot since, outside the Apple ecosystem, you don't even need to know Xcode exists.

There is this belief that Swift is not really useful outside of the Apple ecosystem or is somehow clunky, and that could not be farthest from the truth. In fact, having written a few backends in Swift, I can say that the experience of writing a Swift backend on Linux was much more ergonomic than what I am used to with writing Swift for iOS.

This is useful for testing. Currently, I need to write both the string name of the text and an identifier based on that name for the function itself. Soon I will only need to write it once. This is not much useful for much else though, and just because you can write code like this, it does not mean you should.

A better solution is to have a testing framework that doesn't rely on functions to name tests, especially in a language that has anonymous functions.

We have Quick for this — and while this framework is still a reasonable choice of a testing framework, I personally feel like the new Swift Testing framework is much nicer to write my test cases with.

https://github.com/Quick/Quick

Why do you need both an identifier and a text? I have this test name 'testAddingNewCardDataResultsInProperlyCombinedCardDataButNoNewCardsUnlocksBecauseWeStillHaveUnlearnedCards', and even though it is much longer than my other ones, it is still perfectly readable, and even if it wasn't, the only time I actually have to read it, is if it fails.