Apple can figure it out- they implemented @Published such that it contains a reference to it's enclosing ObservableObject which invokes objectWillChange() very liberally. The fact that they wrote their settings UI poorly is a statement about the developer's assigned to build those components and/or the lack of QA involved.
I do agree that ObservableObject/@Published should have been designed to prevent unnecessary re-renders. It's actually quite easy, and I expect Apple will include this in the future: Add an extension to @Published when the value type is Equatable and only send objectWillChange() when newValue != oldValue. I do something like this in my apps to eliminate superfluous re-renders, but the implementation is non-trivial due to an undocumented feature in Swift [0].
[0] https://github.com/apple/swift-evolution/blob/main/proposa
swiftlang
swift-evolution
Markdown2015–2026
swiftlang / swift-evolution
swift-evolution
This maintains proposals for changes and user-visible enhancements to the Swift Programming Language.
105Distinct people
154Mentions
2Explicit recommenders
15.9KGitHub stars
What to know before exploring
What it is
This maintains proposals for changes and user-visible enhancements to the Swift Programming Language.
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
I love Swift. Writing in it is awesome, the community is great, and it has traditionally been focused on a truly wonderful dev-focused experience. That being said, releases…
joshuawright11 used a recommendation phrase. 2 indexed comments match. This is a phrase match, not a verdict.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
No other repository is repeatedly linked in the same discussions.
This week on Hacker News
Nov 8–Nov 15 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/15/2026, 1:03:20 AM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year154 dated mentions
Observed mentions: 2015-12-03 17:04:39 UTC to 2026-07-10 11:39:51 UTC.
* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 11 | 7 | 4 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 24 | 4 | 20 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 12 | 5 | 7 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 5 | 0 | 5 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 11 | 2 | 9 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 10 | 2 | 8 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 11 | 4 | 7 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 10 | 1 | 9 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 20 | 6 | 14 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 18 | 5 | 13 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 17 | 5 | 12 |
| 2026 (partial) | 2026-01-01 00:00:00 UTC | 2027-01-01 00:00:00 UTC | 5 | 0 | 5 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
Swift Evolution
https://www.swift.org/swift-evolution/
This repository tracks the ongoing evolution of the Swift programming language, standard library, and package manager.
Goals and Release Notes
Swift Language focus areas heading into 2025
CHANGELOG
Version
Announced
Released
Swift 6.4
2026-03-18
2026-09-15
Swift 6.3
2025-10-24
2026-03-24
Swift 6.2
2025-03-08
2025-09-15
Swift 6.1
2024-10-17
2025-03-31
Swift 6.0
2024-02-22
2024-09-17
Swift 5.10
2023-08-23
2024-03-05
Swift 5.9
2023-03-06
2023-09-18
Swift 5.8
2022-11-19
2023-03-30
Swift 5.7
2022-03-29
2022-09-12
Swift 5.6
2021-11-10
2022-03-14
Swift 5.5
2021-03-12
2021-09-20
Swift 5.4
2020-11-11
2021-04-26
Swift 5.3
2020-03-25
2020-09-16
Swift 5.2
2019-09-24
2020-03-24
Swift 5.1
2019-02-18
2019-09-20
Swift 5.0
2018-09-25
2019-03-25
Swift 4.2
2018-02-28
2018-09-17
Swift 4.1
2017-10-17
2018-03-29
Swift 4.0
2017-02-16
2017-09-19
Swift 3.1
2016-12-09
2017-03-27
Swift 3.0
2016-05-06
2016-09-13
Swift 2.2
2016-01-05
2016-03-21
Read the full README on GitHubWhat Hacker News says
10 sourcesIn SwiftUI Is Convenient, but Slow
It's not about the exception, it's about the exception handling.
If 4 tasks are started asynchronously and one of them throws? What do you want to happen to the other 3?
In structured concurency you could say, if any of them fails then cancel all others, and retry them all.
Or for example, if one task is waiting on another and that first task throws an exception, you might want to say, ok, retry the first and re-schedule the other one to wait on that retried task.
These are all things you can handle yourself as well, but structured concurency is just trying to make that less effort and automatic. So if you define a supervision scope, everything inside it no matter how complex the async graph is, it'll all cancel/retry appropriately at that scope.
The scope will also guarantee that when we leave the scope, all concurent tasks are done, not
Read the rest
hing is left running, either because it's all cancelled or the scope waits for all tasks to complete.
Here's some good articles that explains the motivation for it:
https://elizarov.medium.com/structured-concurrency-722d765aa...
https://github.com/apple/swift-evolution/blob/main/proposals...
For simple regexes, Swift has short literals, and (AFAIK) you can mix and match the DSL and the short literals. https://github.com/apple/swift-evolution/blob/main/proposals... gives this example:
// A regex for extracting a currency (dollars or pounds) and amount from input
// with precisely the form /[$£]\d+\.\d{2}/
let regex = Regex {
Capture { /[$£]/ }
TryCapture {
/\d+/
"."
/\d{2}/
} transform: {
Amount(twoDecimalPlaces: $0)
}
}
That gives you control over the verbosity.
Aside: all of this is nice, but does anybody know whether compilation speed (which can be notoriously bad) improved in the latest Swift beta?
In Rulex – A new, portable, regular expression languageSmall question, what are the use cases? From what I understand (I might be wrong), distributed actors is a way to distribute your actors on multiple computers. And again, from what I understand, Swift is mostly used for stuff that runs on one computer, usually an Apple device. To me, distributed actors is something that you need when you build backend stuff. Is Apple planning to use Swift for their backends? Or are they trying to push more the language in general? I can find a bit more information here (https://github.com/apple/swift-evolution/blob/main/proposals...):
> With distributed actors, we acknowledge that the world we live in is increasingly built around distributed systems, and that we should provide developers with better tools to work within those environments. We aim to simplify and push the state-of-the-art for distributed s
Read the rest
ystems programming in Swift as we did with concurrent programming with local actors and Swift’s structured concurrency approach embedded in the language.
But this seems like a "it's a good thing to have" rather than "we need this to do that". This is not to question the choice to add those to Swift, I'm just curious about the use cases. I've done a bit of Swift and I like the language a lot. If this means that we'll see more Swift on the backend, I'm excited for it.
I don't think you should add something complicated like async/await purely for efficiency reasons, but it's good for expressivity too. Coroutines are good; I think you'd end up inventing coroutines and CPS (aka calling a callback at the end of your function instead of returning) just because they're useful, but once you have them, they're unsafe and unstructured i.e. you can forget to call them when you meant to.
Async/await does more than just concurrency; it explodes your function into a rather complicated state machine, but at the same time gives you structured coroutine control flow that prevents some kinds of bugs.
That's why Swift added it before concurrency:
https://github.com/apple/swift-evolution/blob/main/proposals...
Some languages have async/await sugar built around futures instead; this is a mistake and it's less efficient to
Read the rest
o.
Swift has placeholder types as of 5.6, more about them here: https://github.com/apple/swift-evolution/blob/main/proposals...
I mainly use Swift these days but I haven't had a need for them yet so was asking out of curiosity.
In Golang Diaries: GenericsI do not know of any case studies or examples. However, my own code could be considered non-trivial because it's a full build system, or will be.
After writing only enough to get it bootstrapped, I'm now going through and redoing a lot to make it use all structured concurrency. Nevertheless, I don't think it's useful as an example, or rather, it won't be useful once the transformation is done.
> It'd also be interesting to know if all of the behaviour that was expressed in the original structureless concurrency code could be ported across to structured concurrency, or if it was still necessary to use structureless concurrency in a few places as the corresponding behaviour was not expressible.
I have a firm belief that the equivalence of structured and unstructured concurrency is exactly the same as the equivalence of structured and unstru
Read the rest
ctured programming. It has been proven that you can express any possible unstructured program as a structured program. [0] (There is a bit of controversy over the original proof, but as far as I can tell, it has been proven as long as multi-level loop breaks/continues exist. See [1]. This is one reason why my language will have multi-level breaks/continues.)
I personally believe that such a proof exists for structured vs. unstructured concurrency and that it just needs to be found. Part of that belief is founded on [2], which does an excellent job of showing how the `go` statement is really a multi-branch `goto` statement. Perhaps I'll try to discover the proof and write it in a blog post.
(As a first dirty attempt, imagine all of the possible ways you could have more than one concurrent thread of execution. It should be simple to show how to turn every possible use of a `go`-like statement into an opening of a threadset that launches two tasks and waits on them before continuing. I'm not sure how any way of splitting a thread of execution into more than one thread of execution could not possibly be simulated with that. I could be wrong, though.)
Oh, and I just found out that Swift has structured concurrency! [3] This is great! And I think it is the first mainstream programming language with it. I think this is awesome because it means that structured concurrency is going mainstream. I hope it helps structured concurrency win against async/await, which I believe is a poor model.
So if you want a case study, I'd watch the Swift community; someone is going to rewrite their code using structured concurrency and write a blog post about it.
[0]: https://en.wikipedia.org/wiki/Structured_program_theorem
[1]: http://www.cs.cornell.edu/~kozen/Papers/BohmJacopini.pdf
[2]: https://vorpus.org/blog/notes-on-structured-concurrency-or-g...
[3]: https://github.com/apple/swift-evolution/blob/main/proposals...
Swift solved this problems with [non-exhaustive enums](https://github.com/apple/swift-evolution/blob/main/proposals...).
In What I'd like to see in Go 2.0