Back

What’s new in Swift 6.2

185 points27 dayshackingwithswift.com
travisgriggs27 days 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.”

elcritch27 days 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.

ardit3327 days 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.

LudwigNagasena27 days ago

Seems like another case of the general trend in software development of easy things becoming easier and hard things becoming harder.

interpol_p26 days ago

I don't completely agree with you. Having used both SwiftUI and UIKit extensively, I value both of them and think they are both quite strong in different areas

I have published a word game written entirely in SwiftUI [1], the effects and animations would have been much more difficult to do in UIKit, and the app itself would have been hairier to write and maintain [2]. I also track crashes, and this particular app has had four crashes in the past year, so I am very pleased with the stability

That said, there are definitely times, as you say, where you have to drop to UIKit. For the word game mentioned above, I had to drop down to UIKit to observe low-level keyboard events in order to support hardware keyboard input without explicitly using a control that accepts text input

SwiftUI is mature, it's pretty advanced — especially for graphics and animation heavy UI. It has limitations, particularly around advanced input event handling, as well as the application/scene lifecycle

I plan to continue to use both UIKit and SwiftUI where they make sense. It's easy enough to bridge between them with UIHostingController and UIViewRepresentable

[1] https://retrogram.app

[2] Specific examples include: image and alpha masking is trivial in SwiftUI, Metal Shaders can be applied with a one-line modifier, gradients are easy and automatic, SwiftUI's Timeline+Canvas is very performant and more powerful than custom drawing with UIKit. Creating glows, textured text and images, blurs and geometry-based transitions is much easier in SwiftUI

krzat26 days ago

What baffles me the most is testability of SwiftUI. It simply does not exist.

sunnybeetroot25 days ago

This is true, I wonder what Apple uses internally to test SwiftUI.

firecall26 days ago

That’s a shame!

I haven’t used Swift UI in a couple of years, but I always thought the basics of it were excellent.

They got the declarative API foundations right I thought.

Shame it’s still flakey.

The preview used to crash constantly last time I used it.

cevn27 days 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..

eptcyka26 days ago

No one tests multi-user functionality, afaict.

+2
deergomoo26 days ago
+1
crossroadsguy26 days ago
frizlab26 days 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.

rcruzeiro27 days 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

elcritch26 days ago

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.

rcruzeiro26 days ago

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.

msie26 days ago

Too many cooks!

+1
codr726 days ago
+1
mdhb26 days ago
lenkite26 days 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.

interpol_p26 days 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

zozbot23426 days 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.)

cosmic_cheese27 days 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_fishfish26 days 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.

dlachausse26 days ago

Have you tried Skip Tools yet?

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

https://skip.tools/

cosmic_cheese26 days ago

Skip tools is pretty cool and I very may well use it for at some point, but it works by translating Swift+SwiftUI to Kotlin+Compose and I’d prefer a more direct approach that lets me build Android binaries with Swift (preferably with the whole of UIKit available, though that’s not likely).

+1
dlachausse26 days ago
vips7L26 days ago

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

renewedrebecca26 days ago

Feels like a lot of people like making dealing with null as complicated as possible.

cosmic_cheese26 days ago

The only time I ever use it is when the if != null check doesn’t work (aforementioned smart cast failure) and I don’t feel like creating a local var to fix it.

ksec26 days 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.

zozbot23426 days 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.

saagarjha26 days ago

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

moltopoco26 days ago

Stuck in what way? It would have been easy for Apple to make an "Objective-C without the C", where it's still using message passing and the Foundation libraries, but without header files, raw pointers, and all the @messy @syntax. Add little goodies like auto-stringification of enums and so on. I think that kind of superficial cleanup would have been enough to modernize the language. They could have spent the rest of all the time that Swift has consumed on better dev tooling.

+1
zozbot23426 days ago
lenkite26 days 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.

ab5tract26 days ago

Also, if it hadn’t been (slowly) improving all this time then I would have defenestrated my work laptop, myself, or both long ago.

I’m trying to imagine using it without the stream API just shuts my entire brain down. Records arrived pretty recently and are already essential for me.

You will always have to pay me to program Java, but you’d have to pay me 5x my current salary to do it in Java 8 or earlier.

donatj26 days 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?

jmull26 days 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.

JimDabell26 days ago

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

panic26 days 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.

jimbob4526 days 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_cheese26 days 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.

ab5tract26 days ago

Just curious, but would it have been feasible to update the Objective-C compiler to reduce these pain points?

Or was there issue more intrinsic to the design of the language itself?

+1
cosmic_cheese26 days ago
WD-4226 days ago

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

w10-127 days 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.

rockbruno26 days 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.

saagarjha26 days 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.

strongpigeon27 days 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

hudsonator27 days ago

[flagged]

strongpigeon27 days ago

I’d love to believe you, but you’re not giving us much to go on with

dkga27 days ago

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

sedatk27 days 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.

hombre_fatal27 days 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".

sedatk27 days 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.

monkeyelite27 days ago

> case _401 or case error401.

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

iamcalledrob26 days 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.

sedatk27 days ago

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

Defletter26 days 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.

sedatk25 days 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.

Defletter25 days ago

Many of the languages/platforms/libraries that I used (eg: Bun) do not provide any kind of named-constant for this reason: just type 1003. But the value of named constants is that you can attach documentation to them.

To clarify something I said earlier, I would rather have to stop what I'm doing to look at documentation (something that can be done within the IDE) than have to open up a browser and read through the specification to figure out what some magic-value means. Having a provided named-constant that tells me what 1003 means is very useful for me and for other maintainers or contributors to the project, and it can link to the spec for more information anyway. Just having raw magic-values is not great for maintenance. Likewise, having pretty names entirely detached from the actual close-code makes searching for places where that close-code is used much harder. Even just "1003_REFUSE" or "1003_CANNOT_ACCEPT" is so much better.

jshier27 days 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`

DidYaWipe27 days 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.

finalfantasia26 days 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

viktorcode26 days 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.

aatd8626 days ago

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

singularity200126 days ago

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

brainzap26 days ago

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

trevor-e27 days 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.

catapps27 days 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

seankit27 days 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

tough27 days 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

singularity200126 days ago

yep Swift build Works magnificently but only for Mac so far

tough26 days ago

ohh gotcha, well hoping it gets linux/win support soon too, it's great!

viktorcode26 days 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.

catapps25 days 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.

marcellus2326 days 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.

catapps26 days 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)

marcellus2325 days ago

Oh — actually you can create a Swift package and open it with Xcode. You don't need an explicit xcodeproj or xcworkspace.

realaleris14925 days 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.

jmull26 days 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.

myHNAccount12326 days 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.

smotched26 days ago

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

tempaccount42026 days 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.

monkeyelite27 days 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.

adamwk27 days 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.

saghm26 days 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).

adamwk26 days ago

There are lazy collections, but they’re not default.

Why the protocols are designed the way they are is until very recently all types were implicitly copyable, but most of the collection types like array and dictionary were copy on write; so the copies were cheap. I think in general, though, there are a lot of performance footguns in the design, mainly around when copies aren’t cheap. The future protocols will hopefully rectify these performance issues.

monkeyelite26 days ago

Yeah - super weird. It’s like they saw a nice way to avoid thinking about ownership and references, and now have to reconcile with the real problem.

All of these “replace C++” projects have been quite disappointing. Where they tried to make big simplifications they often just didn’t understand the original problem and inherent complexity - or they made a good, but opinionated design choice which has been unable to survive bureaucratic demand for more features, etc.

nhojb26 days 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.

knighthack26 days 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.

viktorcode26 days ago

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

amichail27 days ago

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

klabb327 days 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.

monkeyelite27 days 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.

trevor-e27 days ago

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

favorited27 days 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.

Hashex12954226 days 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?

hn-acct27 days ago

Everything probably already is or should be

bsaul26 days 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_11126 days ago

which is better?

singularity200126 days ago

Swift started from beautiful syntax rust has ugly syntax

Swift is becoming more rust like but also safer

bsaul26 days 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).

viktorcode26 days 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.

Hashex12954227 days 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.

wsc98127 days 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.

wingerlang26 days 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.

rcruzeiro27 days 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.

cosmic_cheese27 days ago

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.

rcruzeiro26 days ago

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.

+1
saagarjha26 days ago
saagarjha26 days ago

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.

ardit3327 days 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.

myHNAccount12326 days 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.

ardit3326 days ago

You are making my point... if you have to use ViewRepresentable in half of the app, then SwiftUI failed. It was supposed to completely replace UIKit, but now it is just another framework to work with...

(makes easy things super easy, but harder/complex things harder).

It has some ways to go......

myHNAccount12326 days ago

Many developers have no issue achieving their desired designs with Representable or just swiftui.

Hashex12954226 days ago

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

So true.

viktorcode26 days 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.

synergy2026 days ago

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

metaltyphoon26 days ago

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

ardit3327 days 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.

ak_11126 days 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?

danielscrubs26 days 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.

andrekandre26 days 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?

hn-acct26 days 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?

xmorse26 days ago

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

DidYaWipe27 days 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.

viktorcode26 days 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() }
    }
}
DidYaWipe25 days 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.

viktorcode22 days ago

> 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.

The restart is there in my example, and it doesn't look too complex. And this aspect of observation is exactly what will be changed in Swift 6.2. Nice improvement, I'd say!

> 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.

If your model stores 2 interdependent states then you'll risk running into infinite update loop regardless of whether you've been notified from `didSet` or `willSet`. It can be fixed by changing the model.

To be fair I didn't understand your example with camera and resolution. In all cases you already know the new value and so the dependent code is good to go. The code shouldn't ever care where the value comes from: the main state, the future state, or some mock state.

hn-acct26 days ago

There is a two parameter onChange modifier btw

90s_dev27 days 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_dev27 days 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."

nulld3v27 days 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.

0rzech27 days ago

Rust does not have this feature. Function names can't have spaces, for example. Underscores are used instead. Maybe there are some macros for arbitrary ASCII strings - I don't know - but it's not a language feature.

+1
nulld3v27 days ago
jibal27 days ago

Zig uses @"arbitrary name"

It's an important feature for FFI, as well as passing operator functions around. (It seems bizarre to me that you can't do `+` in Swift, but I don't know Swift so maybe there's another way to name such functions.)

Also, the Zig library now uses @"..." for variables with the same name as keywords, rather than using ad hoc naming conventions in those cases.

90s_dev27 days ago

Now that you mention it, JavaScript has this inherent problem too:

> foo["hello world!"]()

I'm halfway glad I've never needed to write C++ professionally, but it seems to me like all my TypeScript would probably transliterate to very clean C++31.

wiseowise26 days ago

The issue is that it’s not a problem in the first place.

raydev27 days ago

> languages have had this feature for a long time. Ruby

Yes, that is precisely why I don't like Ruby, it's actually impossible for tools to reason about many things that would make finding bugs before shipping feasible. Big companies like Shopify have to impose a lot of restrictions on it to make it work at scale, which is silly. Just use a different language!

Now Swift may not be in this situation because it's added yet more characters to wrap this nonsense so it is possible to reason about, but it's still just unnecessary, and I will be adding a lint rule against it at work. I don't expect a lot of pushback if any.

jibal27 days 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.

bbatsell27 days 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.

rTX5CMRXIfFG27 days ago

The HTTP status enum example is a _terrible_ one. If you need to represent HTTP statuses and call them by their integer names, why not just pass the damn integer itself? It's exactly what you get in `HTTPURLResponse.statusCode`, and you can already `switch` against it. Already not looking forward to the code that undiscerning devs will mindlessly write just because someone with a huge following wrote a blog.

+1
dagmx26 days ago
tiltowait27 days ago

The backtick syntax for enums is rough, and typing out the full Type.case form negates one of Swift’s niceties (the ability to just type .case if the compiler can tell which enum is in use).

90s_dev27 days ago

I would not have even approved it. But that's just me.

seanmcdirmid27 days 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.

SwiftyBug27 days ago

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

test "strip html tags from string" {

  ...

}
hiccuphippo27 days 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"

thedanbob27 days 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.

Jtsummers27 days 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.

soegaard27 days 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.

codr727 days ago

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

int_19h27 days ago

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

layer826 days ago

You can always work with aliases in that case. No strict need to “contaminate” a language with foreign identifier syntax, in particular if it’s still not 1:1 due to the backticks (e.g. identifiers containing backticks).

codr726 days ago

I'm trying and failing miserably to think of a single example of such a language.

+1
akdor115426 days ago
layer826 days ago

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

rcruzeiro27 days 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_dev27 days 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.

rcruzeiro27 days ago

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

wingerlang26 days 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.

Starlevel00427 days 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.

codr727 days 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.

favorited27 days 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.

arecurrence27 days 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.

storoj27 days ago

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

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

andrekandre26 days ago

  > What is the alternative to Combine's CurrentValueSubject or combineLatest()?
combine latest et al can be found in async algorithms from apple*

https://github.com/apple/swift-async-algorithms

* though current value subject is not there its not hard to make one if you need it

lukeh27 days ago

AsyncExtensions implements many Combine-like patterns in structured concurrency.

jimbokun27 days 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.

90s_dev27 days ago

So it's becoming C++?

codr727 days ago

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

Hashex12954227 days ago

It's becoming Rust.

metaltyphoon26 days ago

For some reason, I find Rust much easier to understand. Swift has so many constructs and special syntax while Rust is much more "tidy" with the syntax.

codr726 days ago

Which I never even bothered with, for that reason.

hirvi7427 days ago

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

rcruzeiro27 days ago

So following this same reasoning Python should become C?

hirvi7426 days ago

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

codr726 days ago

Makes some sense, since its developers probably thought C++ was a pretty good idea, it just needed some more features. Same mindset that killed Rust for me.

I gave up on C++ for good reasons, after spending roughly 20 years trying to make sense of it.

90s_dev26 days ago

Why not just code in a small, sane subset of C++ that you understand perfectly? That's what I do with TypeScript and it works fine.

amichail27 days ago

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

jimbokun27 days 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.

myHNAccount12327 days ago

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

codr726 days ago

You still have to choose, and remember all the variants.

Coming back to a Swift codebase after a few months in different languages is surreal, I can't remember what half of it means.

myHNAccount12326 days ago

Alright, I think I know what you mean - swift does have a peculiar way of completing tasks but I would also say C++ and ObjC do too but I also don't think there are too many ways.

I find you can do apply java and javascript type thinking to swift but they're less preferred.

90s_dev27 days 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?

porcoda27 days 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.

rcruzeiro27 days 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.

afavour27 days 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)

rcruzeiro27 days ago

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

jshier26 days ago

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.

jonny_eh27 days ago

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

lukeh27 days 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...

briandear27 days 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.

ackfoobar27 days 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.

rcruzeiro27 days ago

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

ardit3327 days 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.

AnishLaddha27 days 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.

madeofpalk27 days ago

In my little usage of it (and go and rust), Swift feels like a nice middleground between go and rust. Or, a better (safer) go.

I think Swift is vastly underestimated due to it's relation to Apple.

hocuspocus27 days ago

I don't think people care about its relation to Apple, they care about the language ecosystem, roadmap and evolution that were shaped by Apple's needs for iOS and macOS before there was a real attempt at making Swift more general purpose and multi-platform. And now that it's somewhat there, there are better options in almost every dimension.

favorited27 days ago

I have a few personal and professional Swift on server projects, in the wild and in the works. Code reuse is a big win – we can ~easily expose functionality of our client apps to other systems. Familiarity is another – there's an ocean of iOS (and, to a lesser extent, macOS) developers out there who are familiar with Swift. With a little bit of coaching, they can pretty quickly get up to speed with how services work.

It reminds me a lot of what it was like to ship Node.js software 15 years ago – the ecosystem is still young, but there are enough resources out there to solve 95% of the problems you'll face.

amichail27 days ago

It's a high level language that doesn't get in your way.

rcruzeiro27 days ago

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.

72568627 days ago

The advantage is obvious if you already use Swift.

viktorcode26 days ago

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

Hashex12954227 days 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.

pkulak27 days 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

favorited27 days 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.

pkulak27 days ago

That reference counting is done at runtime. It’s a runtime garbage collector. It’s different than a generational GC, but it’s GC. Those cycles to increment and decrement a counter attached to every object at ever touch aren’t free. All the downvotes in the world won’t make that free.

+1
favorited27 days ago
throwup23826 days ago

> That reference counting is done at runtime.

I thought Swift uses ARC just like Objective-C? The compiler elides much of the reference counting, even across inlined functions. It’s not like Python or Javascript where a variable binding is enough to cause an increment (although IIRC the V8 JIT can elide some of that too).

I don’t disagree that it’s a runtime GC but there’s a bit of nuance to its implementation that resists simple categorization like that.

meisel27 days ago

[flagged]

msie27 days ago

Seriously, smart people making dumb decisions.

90s_dev27 days ago

I can't help but think some of the Swift leads just really like Haskell.

hocuspocus27 days ago

Escaping symbols with backticks to circumvent illegal characters and reserved keywords is a feature coming straight from Scala actually.

+1
msie26 days ago
trealira27 days ago

Haskell names can't have spaces in them, though. Names with spaces is much more reminiscent of Algol 68, or old-style Fortran.