What’s new in Swift 6.2

https://www.hackingwithswift.com/articles/277/whats-new-in-swift-6-2

by ingve • 1 year ago

185 238 1 year ago

hackingwithswift.com

amichail3• 1 year ago

Do you try to put everything on the main actor to dramatically reduce your debugging time?

hn-acct3• 1 year ago

Everything probably already is or should be

trevor-e2• 1 year ago

Main actor by default is a decent strategy. It's usually pretty obvious when something needs to happen off the main actor.

favorited6• 1 year ago

Especially in apps, where most of the code will be about preparing the user interface and handling events. And it's relatively easy to make most lower-level components actor-agnostic – either by making them conform to Sendable, by making them actors, or by giving them their own internal synchronization.

klabb3• 1 year ago

I can’t speak to swift, but in experience with many other langs and runtimes I will say that single-threaded business logic by default is still the only sane choice even today. There are exceptions both on client and server side, but you get so incredibly far with one thread, while eliminating so many potential bugs, that it’s borderline whether parallelism should even be exposed to application developers at all.

Even in Go which has my favorite parallel concurrency model, there are many footguns and needless walking on eggshells for business logic. You can still offload IO and bespoke compute to other threads when it makes sense. This view isn’t a panacea, but damn close for the 99% of use cases.

Coincidentally I also think the early success of JavaScript an largely be attributed to single-threaded run-loop and callback-oriented concurrency. Even on the server JS is still holding strong with this limitation, and that’s despite all the other limitations and insanity of JS.

monkeyelite4• 1 year ago

Absolutely - the idea of threads haphazardly interacting, like 2002 Java, is a terrible default assumption for designing languages and libraries.

It's not even clear the perf gains are great. Everything locking all the time has killed a lot of performance.

Hashex1295426• 1 year ago

Apple effectively solves the problem which doesn't exists.

Before Swift 6, I've worked lot of unique projects both macOS and iOS and never spend time on debugging. I don't know what debugging time exactly?

90s_dev9• 1 year ago

I have not looked at Swift since I last wrote some around maybe v3. I hear that it's generally not a competitor to Rust, and is only really useful within the Apple ecosystem. Why is it not more useful as a C++ alternative, since I think that's kind of what the initial goal was? Is it just that non-Apple support is new-ish and not yet matured? Or a more fundamental issue?

jonny_eh• 1 year ago

Apparently Arc Browser is written in Swift: https://www.reddit.com/r/ArcBrowser/comments/18j39g3/why_arc...

briandear• 1 year ago

Generally only useful within the Apple ecosystem is definitely inaccurate.

An example: https://vapor.codes/

The problem is that people only think it’s generally useful in the Apple ecosystem.

AnishLaddha• 1 year ago

what advantages does swift offer over go/rust/js/java for server side programming? I always presumed the advantages of swift were native code compilation + top tier integration w/the apple ecosystem.

ackfoobar• 1 year ago

I don't use Swift not because I think it's not useful outside Apple, but because I believe its developer experience is poor. Some stories that formed my opinions:

https://news.ycombinator.com/item?id=9947193

https://news.ycombinator.com/item?id=42803489

Granted, my perception may be wrong, but trying it to know for sure costs time. Swift has not earned my time investment.

ardit335• 1 year ago

They have stalled, and the concurency is making things harder to implement right.

Basically, Vapor has to be re-written as it is, in order to work will with swift 6+. Which kinda kills already any little moment it had.

Was looking to use it with a new project, as it is a nice framework, but going with GoLang on the server side due to all this in flux changes.

afavour• 1 year ago

There’s a level of self fulfilling prophecy here: people don’t use Swift off Apple platforms because there isn’t a critical mass of people using Swift off Apple platforms.

But that said it can be frustrating. A lot of the documentation and tutorials you find out there assume you’re on an Apple platform where, e.g. Foundation APIs are available. And the direction of the language, the features being added etc, very clearly serve Apple’s goals.

(Side note: IBM was an early adopter of Swift off-platform but then stepped back: https://forums.swift.org/t/december-12th-2019/31735)

rcruzeiro11• 1 year ago

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

porcoda• 1 year ago

I use it as a C++ alternative on Linux. We ported a substantial code base from C++ to Swift last year and it works great. Performance is better in some places, comparable to C++ in others. Productivity is definitely improved over the C++ codebase. We didn’t use rust for this project after evaluating how that migration would impact how it was designed internally, and we decided it wasn’t the right way to go. I think the “swift is only relevant in apple ecosystem” view is inaccurate these days. Swift certainly isn’t the answer to every project, just like rust or any other language isn’t the universal answer to every project. It’s worth considering though if it is appropriate.

rcruzeiro11• 1 year ago

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.

pkulak4• 1 year ago

You can't really say a language with a garbage collector (Swift) is an alternative to one without (Rust, C++, etc), because a lot of the time, the reason someone is using a non-GC language is because they don't want a GC.

EDIT: Yes, ref. counting is garbage collection, before the replies blow up. haha

favorited6• 1 year ago

a language with a garbage collector (Swift)

You can certainly make the case that reference counting is a form of garbage collection, but it is absolutely false to say Swift has "a garbage collector." There is no runtime process that is responsible for collecting garbage – allocated objects are freed deterministically when their reference count hits zero.

The same thing is true of `shared_ptr` instances in C++, and there's certainly no "garbage collector" there, either.

lukeh2• 1 year ago

Also using it in an embedded Linux project [1]. 75% of code written for this project is Swift. The rest is Dart and C/C++. It’s a productive language.

[1] https://forums.swift.org/t/an-embedded-audio-product-built-w...

Hashex1295426• 1 year ago

For hobby programming at first I picked Java for the alternative to C++ and then Swift since 10 years. I really thought Swift language is the one which going to replace the Python. How dump I am. It's supposed to be. Because of SwiftUI, the direction of Swift language changed. The so called open source label is not fit to the Swift language. May be we can call it as free programming language by Apple.

I used vapor server also and now I think that Swift really has advantage for cross platform development. Just because of SwiftUI they've to adopt nonsense updates. IBM took greater decision on Kitura.

Vapor is still with Swift version 5.9; Let's see how it's ends.

viktorcode8• 1 year ago

Unlike Rust, it has some C++ binding, which is extremely useful.

90s_dev9• 1 year ago

So, rather than writing > @Test("Strip HTML tags from string") func stripHTMLTagsFromString() {...} > we can instead write > @Test func `Strip HTML tags from string`() {...}

Maybe I'm just really new at programming, but this seems like an absolutely bad feature, and the example actually perfectly proves it:

You really want to name a function "Hello World!" instead of helloWorld, just so your stack traces can pass a 5th grade English class exam?

90s_dev9• 1 year ago

It just seems to me that this is the exactly wrong way to solve a programming problem. If the problem boils down to "I want some variables (almost always test function names) to be more human readable", the solution should never be "hey let's add this feature to the core language and make identifiers use any ASCII string! I dunno, maybe I'm wrong here and being overly critical. But to me it just screams "Swift has lost the plot."

bbatsell• 1 year ago

The HTTPStatus enum example is a good one, but the backtick syntax is _rough_. I would only ever use the Type.case form in practice. The test stuff is basically a way to create BDD-style test names, which is kind of just a preference thing. I can’t envision myself using it for anything other than weird case names (I already use case `default` quite a lot because it’s such a useful word), but maybe some interesting DSLs can come out of it? I would not have prioritized that change personally.

nulld3v3• 1 year ago

Many languages have had this feature for a long time. Ruby, ~~Rust,~~ Kotlin, etc... It hasn't been an issue at all.

I like that most languages seem to have reached consensus on backticks or other similarily awkward characters for this feature. Typing these identifiers is like hitting a speed bump, which seems to be enough to make devs avoid them except for very specific use-cases.

jibal2• 1 year ago

Test names are just an example. There are other valid reasons to be able to use arbitrary strings as names--importing functions from other languages and names that clash with keywords, for example.

hiccuphippo• 1 year ago

Naming things is hard. If you can more accurately describe your test and not think of a separate name for it I'm all for it.

Also I like the backticks better than what zig came up with: @"404"

thedanbob• 1 year ago

I don't know about other languages but Ruby is similar in that you can name a function with any string (though you might not be able to call it in the standard way) and the Rails default test framework takes advantage of that.

Jtsummers• 1 year ago

https://tio.run/##S87JLC74/18jJTWtNE@hJiM1JydfoTy/KCelRkFDk0...

Common Lisp allows it as well, though I don't think I've ever seen it done outside a demonstration that it can be done.

seanmcdirmid• 1 year ago

Tests are never called explicitly by programmers, or at least they never should be. You could argue that they don’t really need to be functions at all, just pieces of code that represent tests.

SwiftyBug• 1 year ago

That's how Zig tests work. This is basically a function with a different syntax.

test "strip html tags from string" {

  ...

}

soegaard• 1 year ago

The feature is fine but there are better reasons to introduce it.

For macro generated code it is convenient to use identifiers that people won't accidently use in their own code. The ability to use arbitrary identifiers solve that.

codr710• 1 year ago

Except people can also use arbitrary identifiers in their own code now?

int_19h• 1 year ago

The other reason is interop with other languages, which might have their own rules for identifiers.

layer84• 1 year ago

It lessens the likelihood of a collision, but doesn’t remove it.

Starlevel004• 1 year ago

Kotlin has this, but it's basically only ever used for tests. I've never seen a real world method with a backtick name.

rcruzeiro11• 1 year ago

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.

90s_dev9• 1 year ago

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.

wingerlang2• 1 year ago

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.

codr710• 1 year ago

There's a lot I love about Swift, but I fear it's quickly becoming too complicated for its own good.

There are just so many ways to solve a problem now that it's more or less impossible for someone to be familiar with all of them.

90s_dev9• 1 year ago

So it's becoming C++?

hirvi742• 1 year ago

Considering Swift was primarily written in C++, perhaps Swift was always destined to follow the same path?

codr710• 1 year ago

That's my feeling, and it makes me sad because I have largely given up on C++ for that reason.

Hashex1295426• 1 year ago

It's becoming Rust.

arecurrence• 1 year ago

I too wish deprecation with migration path was a more common pattern in today's language development. The language has very much needed work and the numerous bugs within Apple's own libraries certainly hasn't helped.

That said, some of the, erm, "new ways" to solve problems have been significant advancements. EG: Async/Await was a huge improvement over Combine for a wide variety of scenarios.

storoj• 1 year ago

IMO async/await and Combine are two completely different things.

What is the alternative to Combine's CurrentValueSubject or combineLatest()?

amichail3• 1 year ago

Is having too many ways to solve a problem an issue for solo indie developers?

myHNAccount1235• 1 year ago

Right? I don't get this persons sentiment and I don't understand how it relates to the post in particular.

jimbokun2• 1 year ago

It can be if you keep adding the new way of doing things and then need to debug code that jumps between all the different ways of doing things.

favorited6• 1 year ago

Many of these features have convoluted-sounding names like "global-actor isolated conformances" or "control default actor isolation inference," but they are changes that make actually using the language simpler.

People aren't expected to really learn that there is a "feature" called global-actor isolated conformances, but at some point they'll try to make a UI type conform to `Equatable,` and instead of an error saying you can't do that, they'll get a fixit about needing to specify the conformance as `struct MyUIType: @MainActor Equatable` instead.

I bet 99% of codebases won't use "method and initializer key paths," but there's really no reason why you should be able to get a key path to a property, but not a method. It just hadn't been implemented yet, and the language is more consistent now.

Personally, I think raw identifiers are kinda dumb, but that just means I won't use them. IMO there isn't really more cognitive overhead when using the language because it's possible to use spaces in function names now.

jimbokun2• 1 year ago

Yeah, I’m not an active Swift developer. But reading this article about all the existing complexity and all the new complexity in this update makes me think Swift has jumped the shark.

sedatk4• 1 year ago

Free-form identifiers are neat for test-case naming, but not for `HTTPStatus.`404``. I think having `HTTPStatus.Error404` was a bad idea to begin with. Just use semantic names like `HTTPStatus.NotFound` and you wouldn't have a problem in the first place. Now, a single character typo can easily make a 404, 403 and create a bug. It's less of a problem with semantic names.

If you want constrained numeric types in Swift, that's another problem to tackle. But `HTTPStatus.`404`` seems to be the least ideal way to go about it. It lets you do stuff like to declare `HttpStatus.`404`` with a value of 403 too.

jshier2• 1 year ago

Yeah, the feature is mostly about test cases and macro generated code. The numeric property names are far less useful, as the good syntax requires tick marks: .`404`

hombre_fatal2• 1 year ago

You might mess up 403 vs 401 in this system, but then in the next system you're messing up Unauthorized vs Forbidden.

It's like when you see a poisonous snake and can't remember if "red touches yellow" is paired with "deadly fellow" or "friendly fellow".

sedatk4• 1 year ago

Messing up Unauthorized vs Forbidden is a semantic problem, but 403 vs 401 can be either semantic or syntactical. It’s not like you’d mispress a key and get Forbidden instead of Unauthorized.

monkeyelite4• 1 year ago

case _401 or case error401.

I'm not seeing why it's worth a whole language feature to avoid prefixing strange identifiers.

sedatk4• 1 year ago

I don’t think it’s the sole reason, but I find that example odd for sure.

iamcalledrob• 1 year ago

I think this is kind of indicative of the Swift approach: if in doubt, add language features that make code look nicer.

Not a fan personally, but Swift is littered with little "niceties" (complexities) like this.

DidYaWipe3• 1 year ago

Yeah, this feature seems wholly unnecessary and possibly dumb. The example given is ridiculous.

If you can't figure out what stripHTMLTagsFromString() does, you have way bigger problems than a lack of spaces.

Defletter2• 1 year ago

Just use semantic names like `HTTPStatus.NotFound` and you wouldn't have a problem in the first place.

Have to disagree there: when I tried re-implementing a basic websocket server in multiple languages (https://news.ycombinator.com/item?id=43800784), I found it so frustrating when they'd insist on hiding the raw close-codes behind pretty names, because it meant having to stop what I was doing to jump into the documentation to figure out what pretty name they gave a particular close code.

All I wanted was to return 1003 (https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.1) if the websocket sent a string message, but:

- Dart calls this "unsupportedData" (https://api.dart.dev/stable/latest/dart-io/WebSocketStatus/u...)

- Java-Websocket calls this "REFUSE" (https://javadoc.io/doc/org.java-websocket/Java-WebSocket/lat...)

- Ktor calls this "CANNOT_ACCEPT" (https://api.ktor.io/ktor-shared/ktor-websockets/io.ktor.webs...)

And some others:

- .NET calls this "InvalidMessageType" (https://learn.microsoft.com/en-us/dotnet/api/system.net.webs...)

- libwebsockets calls this "LWS_CLOSE_STATUS_UNACCEPTABLE_OPCODE" (https://libwebsockets.org/lws-api-doc-main/html/group__wsclo...)

Just... why? Just call the thing 1003 and link to the spec.

sedatk4• 1 year ago

If you don’t want to deal with that, you can just use the number. Some APIs have integer overloads for that purpose, but you can also typecast. I don’t find HTTPStatus.`1003` more helpful than 1003.

w10-1• 1 year ago

The article doesn’t give enough attention to the glacial but steady changes in the ownership model that will have great benefit in avoiding copies in value types, Swift’s strength and Achilles heel.

I have to say Paul Hudson has almost single-handedly taken over communicating the essentials of Swift to the world; he’s fantastically reliable, brief but enthusiastic, guiding people around the many pitfalls.

strongpigeon• 1 year ago

Agreed about Paul Hudson. He also just seems like a genuinely nice guy. I was kind of shocked to receive an email from him out of the blue last weekend (well, from GitHub, but with his name in the "From" field). Turns out it was about a PR [0] to one of my packages where he fixed typos in the README.

[0] https://github.com/visfitness/reorderable/pull/2

dkga• 1 year ago

The last sentence is exactly how I would describe Paul Hudson, as a HwS reader/user.

rockbruno• 1 year ago

Agree on Paul Hudson being great, but not so much on the guiding around the pitfalls. One big issue with the Swift community in general in my opinion is that a lot of the community content is incredibly shallow. Most of them are fine with "there's this feature and you can do X with it, cool right?" style-content, meaning very few people actually take the time to explain what the trade-offs are / performance considerations / how things work under the hood, and IMO this took a huge negative hit in the average skill level of Swift developers.

saagarjha5• 1 year ago

I think one of the problems is that the people who are actually using the language features generally don't have time to do it, Apple doesn't do it themselves, and Paul Hudson has 300 new features a year to view. Plus, iOS developers cargo cult harder than any other programming community I've come across, and this generally doesn't work really well if your explanation is difficult to quickly convey.

trevor-e2• 1 year ago

Lot of nice improvements here. I'm actually quite liking the async API after using it in a couple small apps and learning the fundamentals.

I really wish the entire Swift team would spend a quarter fixing bugs and improving the compiler speed, though. So many trivial SwiftUI cases trigger the "this is too complex for the compiler" errors which are so frustrating to fix.

catapps3• 1 year ago

I've been starting to use Swift again lately after like four years, and while the language is beautiful & the package management story is now a LOT better with SwiftPM, I found that none of it plays nicely with XCode, Simulator, or anything to do with iOS/macOS development -- its primary use-case!

I found myself awestruck that I *HAD* to use XCode or xcodebuild, and could not just run `swift build` and generate an iOS app.

In the end, I had to:

- compile the .app structure myself

- run codesign manually

- manage the simulator manually

- bundle xcAssets manually

- provide swift linker flags manually targeting the toolchain/sdk I needed

- manually copy an embedded.mobileprovision

It was a good learning experience, but what's the story here? Did Apple just give away Swift to the OSS community and then make no ongoing effort to integrate their platforms nicely into the non-xcode build tooling? Looking into https://github.com/stackotter/swift-bundler

seankit• 1 year ago

The Swift language team has recently open sourced swift-build, and the community's assumption is that it was done in order to eventually move everything away from xcodebuild to swift-build, which would let you build an app from swift packages and fully break from Xcode: https://github.com/swiftlang/swift-build

tough2• 1 year ago

yep can confirm swift build works, at least i was able to build a MacOS app and avoid Xcode at all costs thanks to it phew

marcellus232• 1 year ago

I'm confused. You said "none if it plays nicely with Xcode" but then you complain about what the experience is like when not using Xcode.

catapps3• 1 year ago

As far as I could tell, if you create a Main.swift file, you can't just open that in XCode and start running it as an iOS/macOS application, and instead have to create a .xcodeproj/.xcworkspace through XCode, and add your Swift to the scaffolded project - this seems backwards to me.

(I then separately complained at all the steps it took to get it running without XCode, as I didn't want to be locked into using it)

realaleris149• 1 year ago

Not op, but I think "doesn't play nicely" means does not work so you have to do it in other ways. This has been my experience as well, albeit it was couple of years ago.

viktorcode8• 1 year ago

You are talking about the language but bringing up an example of creating an app for an Apple platform. Regardless of the language you will have to create app bundle structure, copy assets inside, add mobile provision and sign it.

If you ask me, those platform specific things should never be integrated part of the language.

catapps3• 1 year ago

Sure, but developing for Apple's platforms is Swift's primary use. I'd say Dart & Flutter is a fair comparison:

As flawed as they are in my eyes, its dev tooling quality is something I appreciate and wish I saw here. There are two CLIs, one for the language (Dart) and one for the framework (Flutter). Some would say that the CLI equivalent would be xcodebuild, but that depends on the complex .xcodeproj/.xcworkspace structure and still requires XCode to be installed.

Hashex1295426• 1 year ago

Mostly nonsense updates.

Swift was my favorite programming language after C++/Java since 2014. I've been faced major updates few times happily. It was one of the most easiest language. But now,

I tried to update a project from Swift 5.x to 6.x which has 150+ source files itself and no external libraries which is written by my own use and it has almost all swift 5.x features. They made up Swift as super hard. I decided not to use Swift 6 anymore and yes I don't need to reduce debugging time, Even though I don't have powerful computer and debugging time isn't matter to me & development time is actual matter to me.

The language itself becomes Rust (the programming language using by aliens). I Hope Swift language is upgrading itself for Aliens or the Swift team is filled with Aliens. Now, I feel ObjC is super easiest language than Swift.

PS: I understand Swift is Corporate Product & upgrading towards SwiftUI than general purpose programming language. I never gonna use Swift 6 even I do use ObjC for my projects.

wsc981• 1 year ago

I find 'simple' languages charming. Hence, I still like Objective-C. I also like Lua a lot.

I liked Swift when I tried it a couple of years ago, but it seems overloaded with features these days. I haven't tried Swift UI yet, but I did think the Objective-C approach with xibs, struts and such worked fine.

rcruzeiro11• 1 year ago

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.

wingerlang2• 1 year ago

There is probably around a decade-long leap between XIB and SwiftUI. XIB files are only found in legacy code nowadays. It might have worked fine in smaller projects, but I think there are good reasons why it was left behind.

In my experience, most XIB files were either so small and easy that it was simply easier to replicate it in ten lines of code. Or so giant an impenetrable that it took thousands of lines of code to replicate it with, and at that point most people prefer to work with code over a dense XIB file.

ardit335• 1 year ago

I don't use the new concurrency features, as they are one of the main culprits of this mess. (so stick with 5.x)

SwiftUI is a wreck, that is still not good for advanced UI and you still have to use UIKit for some parts, and

Taking Objective-C, with DispatchQueue, and some modernization of it, and some new data structures, which it need, was all it was needed to make a good new langue.

It could have been Apple's rival to GoLang, but instead it ended up being hydra/monster with too many pardagimns, and none of them are good.

Hashex1295426• 1 year ago

but instead it ended up being hydra/monster with too many pardagimns, and none of them are good.

So true.

myHNAccount1235• 1 year ago

SwiftUI is a wreck, that is still not good for advanced UI and you still have to use UIKit for some parts, and

Skill issue. *ViewRepresentable exists.

viktorcode8• 1 year ago

My guess is you've encountered issues with actor isolation made suddenly explicit in your language upgrade. This is exactly what's addressed in Swift 6.2, so it won't be nonsensical in that case. Speaking from my personal experience of trying to upgrade and stopping.

The moment this language version is released I will move to Swift 6. In our project case it will happen. with no source code changes.

Hashex1295426• 1 year ago

Yes, https://stackoverflow.com/questions/79589648/actor-isolated-...

travisgriggs• 1 year ago

Honest question. Not trying to troll. One of the pitches in the earlier days was “C/Objective-C OK, but you can’t write safe/next level code with it—-Swift will close that gap.”

N years later, it doesn’t feel like there has been a step change in Apple software quality; if anything Apple software feels less solid, and looks cool “look what I did” extension points. I mean, some of the tings you could do with runtime categories, and runtime prototypes were really cool. Now when I work on my 2 apps that originally happily port to Swift/UIKit, I’m just left confused with how to make things work. I’m happy when it finally works, and don’t ever try to improve the thing, it’s too much work.

There’s lots of different variables at play here; I’m not trying to stretch inference too much. Heck, it could have been that with adding Swift to the mix, the forces that have contributed to reduced quality in Apples stuff would be even worse.

I’m just frustrated. When I work in Elixir, I’m like this is cool. When I work in Kotlin, I don’t feel like “Apples got a language like this too, but it’s got that extra special zing that used to make stuff Apple touched cool.”

elcritch3• 1 year ago

I feel the same. Apple software quality certainly hasn’t increased. Years back I remember some apps crashing suddenly after updating MacOS. I checked the binary and saw they’d started adding Swift.

Half a decade later it seems like it should be better and Swift stuff should be stabilized. But nope, I’ve had more little glitches in both iOS and MacOS. It’s hard to say it’s due to Swift, and not management priorities. Still it feels partially related to Swift.

Swift’s goals are great, I like the syntax, but the language implementation seems to just special case everything rather than having coherent language design.

That and Swift de-emphasizes Obj-C message passing. I have a pet theory that message passing produces more robust GUI software that’s easier to adapt to complex needs.

rcruzeiro11• 1 year ago

Swift’s goals are great, I like the syntax, but the language implementation seems to just special case everything rather than having coherent language design.

This could not be furthest for the truth. The entire process of proposing a new language feature to getting it implemented and shipped is out in the open for everyone to participate/see.

https://github.com/swiftlang/swift-evolution

ardit335• 1 year ago

It is not just the language but the frameworks. SwiftUI is a wreck, and still not mature even after 6-7+ years in 'production'. You still have to drop to UIKit to do advanced UI, and for what it is, SwiftUI is just not practical enough for cases that are not trivial. The trouble is that all new kids/engineer are learning it first, which means software wont get better. Apple need to improve it first, and I don't see advanced folks ditching UIKit anytime soon for advanced UI.

cevn2• 1 year ago

I have a good bug right now. My wife bought a Macbook Air. I use High DPI and she does not. It is impossible to switch between users in this situation, one of the core functionalities of the computer is just broken. Makes me wonder if anyone at Apple uses these computers..

frizlab• 1 year ago

That doesn’t mean much. Swift is new. Usable Swift even more so. All of the apps Apple propose have legacy. New apps from now (e.g. Invites) will be much more interesting.

cosmic_cheese8• 1 year ago

As someone frequently flipping between Swift and Kotlin, while I don’t necessarily feel like Swift is massively superior, I often find myself thinking “why is this so quirky and pedantic” when writing Kotlin.

For example, I really really wish Kotlin would adopt Swift style if let/guard let statements. Kotlin smart casting doesn’t work just often enough to not be able to consistently rely on it and the foo?.let { } syntax is ugly.

Combined with the JVM warts of gradle and jankiness of code stripping and obfuscation, generally speaking if I could opt to use Swift in place of Kotlin for Android dev I would do so in a heartbeat.

joe_fishfish• 1 year ago

Ha, I switch between the two as well, but I feel the opposite. Kotlin is much more intuitive for me, and Swift is more clunky. I do miss guard lets in Kotlin, but that’s about it.

_mlbt3• 1 year ago

Have you tried Skip Tools yet?

It’s a set of tools intended to do just that.

https://skip.tools/

vips7L• 1 year ago

The ?.let syntax is terrible. I don’t see how anyone thinks it’s better than doing a normal if != null check.

jimbob45• 1 year ago

Surely developer productivity and maintainability have increased from the ObjC days, no? Swift criticisms aside, it certainly allows access to more ergonomic high-level coding patterns.

cosmic_cheese8• 1 year ago

A big one that I feel is under appreciated is how Swift has rooted out nearly all passing around of untyped data, untyped dictionaries, casting without checking, etc in Apple platform projects.

I don’t mind Objective-C when I’m the one writing it and can ensure that the code is responsibly written, but it wasn’t unusual to have to work on existing Obj-C codebases littered with untyped data, casts, etc some amount of which was inevitably erroneous and only seemed to work correctly. Chasing down the origin points of data, fixing a laundry list of method selectors, and adding in checks always sucked with the compiler doing little to give you a hand. With Swift, even in codebases with poor hygiene fixing things is easier since the compiler will yell when something’s wrong.

WD-42• 1 year ago

This might just be the long term effects of a platform dominated by people who generally value hardware over software.

panic• 1 year ago

Swift wasn't designed to solve any of the problems Apple engineers had writing customer-facing software. It was a shiny new language which could be marketed to third parties as something modern and familiar, unlike Objective-C with its odd mix of C and square brackets.

ksec• 1 year ago

I have been skeptical of Swift ever since I heard the original goal was the one language to rule them all from Assembly to Javascript. When something is too good to be true it probably is. But I have also given Apple plenty of benefits of doubt.

It seems Swift 6.2 is still unfinished and is acting more like Java. Eternal evolution of language. While it is popular among tech and HN crowds to have new language and framework to play around and work. It brings particular little if not negative user experience in terms of final products. I often wonder if Apple could just have some light touches of improvement on Objective-C in the past 10 - 12 years and instead focuses on actual OS and Apps quality.

It is this lack of focus that has been with Apple since Steve Jobs left.

saagarjha5• 1 year ago

Objective-C being stuck in the 1990s forever was not necessarily a good thing.

zozbot2343• 1 year ago

It seems Swift 6.2 is still unfinished and is acting more like Java. Eternal evolution of language. While it is popular among tech and HN crowds to have new language and framework to play around and work

You can have both. Rust feels "mature" and "finished" if you stick to the stable featureset, but it's still bringing compelling new features over time in spite of that. But this can only be achieved by carefully managing complexity and not letting it get out-of-hand with lots of ad-hoc special cases and tweaks.

lenkite2• 1 year ago

Umm...Java is extremely conservative in adding new features. Not really sure you can compare to Swift that throws 10x the features in with every major release.

lenkite2• 1 year ago

Software written in a simpler language like Objective-C - verbose, fast to grok and fast to compile is actually more maintainable in the long run than a so-called "developer friendly", humongous, complex and slow-compilation language like Swift.

A lean language reduces the surface area for beautiful expressiveness by clever people - making sure the dumb/junior guy who is maintaining your project in the future can actually fully understand what is written. And it can build and run fast - so you can iterate and test out software behaviors fast.

No one in this world is immortal. If it takes too much time to grok code, write/compile/run tests - a developer will be disincentivized to do so, no matter how amazing the language features are.

My guess is that Swift has adversely affected Apple's overall software quality. As more software moved from Objective-C to Swift, quality has dropped precipitously.

zozbot2343• 1 year ago

There's a limit to how "lean" a safe, low-level language can be. Rust is leaner and simpler than Swift but not by much, and pretty much all of its outward features are "load bearing" to a far greater extent than Swift's.

(People have tried to come up with simpler languages that still preserve safety and low-level power, like Austral - but that simplicity comes at the cost of existing intuition for most devs.)

interpol_p2• 1 year ago

It's easier to read and navigate a well-written Swift codebase than a well-written Objective-C codebase

Conversely, it's easier to debug an Objective-C app than a Swift app, simply because compiling and debugging is so much faster, and debugging so much more reliable

I don't know about a software quality drop being attributable to the migration to Swift. So many other things have also happened in that time — much more software that Apple produces is heavily reliant on network services, which they are not very good at. I find Apple's local-first software to be excellent (Final Cut Pro X, Logic, Keynote) and their network-first software is hit-or-miss

They have also saddled developers with a ton of APIs for working with their online services. Try to write correct and resilient application code that deals with files in iCloud? It's harder than it was to write an application that dealt with only local files a decade ago!

Swift is easy to blame, but I don't think it's responsible for poor software. Complexity is responsible for poor software, and we have so much more of that now days

JimDabell• 1 year ago

It’s easier to write more robust code with Swift, but if Apple don’t prioritise quality, the language can’t fix that.

jmull2• 1 year ago

Good code is just one of many ingredients to great software, and programming language is a small factor in good code.

Swift was never going to make Apple software great (nor Go or Rust or anything else for anyone else).

Though, honestly, if you're thinking about computer languages in terms of cool, you're going in the wrong direction.

donatj• 1 year ago

It's second system syndrome combined with the fact that Objective C and the NeXT underpinnings were put together by a team of truly the greatest minds of a generation.

Swift was put together by some great minds, and some minds, Apple still attracts talent, but in far lower density. This isn't even a jab, just from the fact that they are far larger and the talent pool is smaller with far more competition.

What percentage of genius level developers want to work for a company where they can't talk about their work and generally get zero public credit?

ardit335• 1 year ago

Swift is amateur hour in action by academics that don't value practicality. The new Concurrency was ill thought, and done by people that just perhaps either don't have enough practical experience, or are so enamored with the actor paradigm (erlang) that they had to shove it down the throat in a ecosystem where it is not used that much. No one is really using Swift for distributed programing.

Glad they are backtracking on this, and I hope they start remove features and simplifying things. Swift's enemy is its own self and the people steering int into just an academic exercise, rather than a practical and performant language that can be used in many domains. Server side Swift right now is dead due to all these insane changes.

Hopefully things get better on the server/other non ios domains, but the language needs to get simplified and become practical and fun to use.

andrekandre2• 1 year ago

  > or are so enamored with the actor paradigm (erlang)

swift actors are barely actors in the erlang sense, not even close

maybe you're referring to structured concurrency?

danielscrubs• 1 year ago

Academics value simplicity and fundamentals… Swift with its timeouts smells of Big Company incentives where everyone wants to make a contribution and management that see themselves as babysitters instead of product creators with competition.

ak_1112• 1 year ago

Isn't there some contradiction in your comment, I would have thought that distributed programming is precisely the thing that server side programming needs most?

hn-acct3• 1 year ago

It’s opt in. Very explicitly opted in. Did you read the post? Because it improves actors and makes it easier for app devs and general programming use cases. Honestly I don’t get the “sky is falling” mentality towards swift because a feature they won’t use or are affected by is added.

“Due to these insane changes” Which changes?

monkeyelite4• 1 year ago

InlineArray does not conform to either Sequence or Collection

Why not? Does this mean I need to make a struct which wraps InlineArray and implements Collection? Why didn't they do that?

EDIT: found the answer (I still have concerns):

While we could conform to these protocols when the element is copyable, InlineArray is unlike Array in that there are no copy-on-write semantics; it is eagerly copied. Conforming to these protocols would potentially open doors to lots of implicit copies of the underlying InlineArray instance which could be problematic given the prevalence of generic collection algorithms and slicing behavior. To avoid this potential performance pitfall, we're explicitly not opting into conforming this type to Sequence or Collection.

adamwk2• 1 year ago

There’s a section in the proposal about this: https://github.com/swiftlang/swift-evolution/blob/main/propo...

Tl;dr: Sequence and Collection are incompatible with noncopyable types and conditionally conforming when elements are copyable would result in too many implicit copies. They’re working on protocols to cover noncopyable collections such as this, which will probably have a similar API shape.

saghm• 1 year ago

Interesting; if I'm understanding correctly, it sounds like Swift doesn't have a standard lazy iteration API yet? I would have guessed that it did if asked before reading this, but it's good to hear that they're already working on it. Since I feel super spoiled by lazy iterators in Rust, I'm super curious if anyone has more Swift experience and could chime in on if there are other language features or APIs that might illuminate why there wasn't as much of a need for this earlier; my general perception of Swift as an outsider is that it tends to have pretty well-thought out decisions based on factors that I just happen not to know about personally (e.g. compatibility with other parts of the Apple software ecosystem or different priorities due to the domains Swift is often used in compared to the type of stuff I work on personally).

DidYaWipe3• 1 year ago

"a new Observations struct that is created with a closure, and provides an AsyncSequence that emits new values whenever any any @Observable data changes"

Is this another asinine onChange()-style mechanism that actually means WILL change? In other words, it tells you BEFORE the value is set on the object, so you can't do jack squat with it much of the time.

That's the M.O. of onChange now, which is utterly brain-dead. Gee, I've been told that a value changed in this object, so let's recalculate some stuff. WHOOPS, nope, none of the other objects (or hell, even the affected object) can take action yet because they can't interrogate the object for its new contents.

Truly incredible that they not only defaulted, but LIMITED change-detection to WILL-change, the least useful of the two choices.

viktorcode8• 1 year ago

Truly incredible that they not only defaulted, but LIMITED change-detection to WILL-change

That's not strictly true. You get the new value inside the closure. This is very useful for observing changes on data model that drives SwifUI from outside of SwiftUI. Before you had to write the code like this to achieve that:

func startObservation() { withObservationTracking {

        print(store.state.toggle) // Here we have the new value (+ it is called once before any change)

    } onChange: {
        Task { startObservation() }
    }
}

DidYaWipe3• 1 year ago

I know that you get the new value; but in many cases (almost every case I encountered), that doesn't help. You mention

"This is very useful for observing changes on data model that drives SwifUI from outside of SwiftUI"

I disagree, because the model hasn't changed yet. That's the crippling aspect to it: You can't tell some controller object to recompute its state based on a change to another object in the model, because you're getting notified BEFORE that object has changed.

For example, if I have an object that represents a camera, and the user tweaks a value in the UI that changes its resolution, the camera might offer a different set of values for things like frame rate.

So if I get notified that the user changed the resolution, I can't then tell the Recorder object to recompute the remaining recording time based on the camera settings, because those settings will not have changed yet.

And incidentally, I've used startObservation() in places, and it's crippled by another idiotic design choice: It only works once. It reports the first change, and then never another one. So in the onChange closure, you have to re-start the observation. Every goddamned time.

It's another great example of serving only the most illogical and obscure use case. Who the hell would expect something called "startObservation" to just quit after one change? The stupidity is just galling.

hn-acct3• 1 year ago

There is a two parameter onChange modifier btw

finalfantasia• 1 year ago

“Swift has turned into a gigantic, super complicated bag of special cases, special syntax, special stuff…”

— Chris Lattner, 2024

https://blog.jacobstechtavern.com/p/apple-is-killing-swift

singularity20013• 1 year ago

how can the next great language avoid the trap of syntax bloat while providing the same extraordinary functionality

brainzap• 1 year ago

By not providing them. Say "sorry, here is an ugly workaround, generate this xy code."

aatd86• 1 year ago

I wonder why the author left Go out of his list of examples of language stewardship.

viktorcode8• 1 year ago

As he mentioned in a forum post some years ago, Chris wanted the language to be more modular, but Apple's drive for adding features to it sets very different priorities.

To be fair, every new language version usually includes things that eliminate those special cases making writing the code more straightforward. Like the described support of functions in key paths, or the ability to set default global actor isolation.

bsaul2• 1 year ago

Coding in both swift and rust is really a funny experience. It's like two roads being built going toward the same city, but starting from widely different places.

ak_1112• 1 year ago

which is better?

singularity20013• 1 year ago

Swift started from beautiful syntax rust has ugly syntax

Swift is becoming more rust like but also safer

viktorcode8• 1 year ago

The actual targets are very different. For Rust is to be memory safe and available at any level starting from embedded. For Swift it is to be readable.

bsaul2• 1 year ago

i think i prefer swift as a language, and rust as an ecosystem. The amount of quality libraries in rust is astounding.

But that may change with swift getting more and more into safety and reaching the limits of how many keywords a language can have and remain descent. I honestly don't know what the feeling of learning swift would be like today.

And on the other hand, i don't see how the rust language can really get nicer without sacrificing on a few design decisions and goals (in order to keep the language extremely versatile).

nhojb• 1 year ago

Swift is collapsing under the weight of its increasing complexity. So many, many special cases & they keep adding more!

As a developer it becomes so very hard to reason about code behaviour. This is especially true with concurrency, which was meant to simplify concurrent operations, but in actual fact is a nasty can of worms. In an effort to "hide the complexity" it just introduces a huge amount of unexpected & hard to grok behaviour. The new "immediate" Task behaviour & non-isolated async behaviours are good examples of this.

knighthack• 1 year ago

Swift's become so feature-heavy, and complex, whilst the documentation is all over the place. That's not even counting things like SwiftUI, or its rather arcane CLI tooling.

Out of curiosity, I put in more than 150 genuine hours in 2024, trying to get deeply into Swift - and eventually just abandoned the language.

In comparison - I got very far experimenting with Go in the same amount of time.

Unless one needs to get into the Mac ecosystem, I see no reason why learning Swift should be necessary at all.

synergy20• 1 year ago

read news about rust and swift these days, it seems modern c++ might keep its dominance for the future

metaltyphoon2• 1 year ago

Rust doesn't keep adding features like Swift is. There is a lot of stabilization happening.

jmull2• 1 year ago

It sure feels like Swift governance is broken.

They're just shoveling stuff in to the language.

Individually, most items aren't so bad, but collectively they've got a mess and it's getting bigger fast.

None of the decision-makers seem to have the sense or incentive to say "no" to anything.

It's sad, because the language had such promise and there are some really nice things in there.

Well, at least it's relatively easy to avoid or ignore.

tempaccount420• 1 year ago

That's a matter of taste.

I enjoy "bloated" languages. Many languages are bloated nowadays, but the community agrees what set of features to use, what to avoid. Still, those rare features can be useful for stuff like making DSLs through clever use of the language.

It's much worse to have a minimal language that takes years to add new features, like how Go took over a decade to add generics.

myHNAccount1235• 1 year ago

None of the decision-makers seem to have the sense or incentive to say "no" to anything.

How could you know that? Not all the 'no's show up as a proposal. The proposal template also has an "Impact on ABI" section which you can use to guide your "can I ignore it"-sense.

It sure feels like Swift governance is broken.

What is the actual problem though? Not enough features that you would use? But I don't see how this is a governance problem

Java governance: slow at times but mostly sane. C++ governance: I won't even open this can of worms. Swift governance according to you: too many features I will ignore.

smotched• 1 year ago

People like this just complain. Without pointing to anything real or saying anything meaningful. You just have to ignore them like spam.

viktorcode8• 1 year ago

Spans and inline arrays are the two missing pieces of performance puzzle Swift needed. I'm super hyped for the release!

xmorse• 1 year ago

does it really matter if it takes 1 hour to compile?

What’s new in Swift 6.2

Related Stories