6 ms·

For current Rust users, if Rust kicks the bucket, Swift is a good plan B.

AceJohnny2 3y ago
I find it very notable that Graydon Hoare, the "founder" of Rust, went on to work at Apple on Swift for a while. Also, Swift had tremendous work to implement ABI stability[1], which really allows it to be used as an OS API, which Rust can't do. [1] https://faultlore.com/blah/swift-abi/ https://faultlore.com/blah/swift-abi/
- biorach 3y ago
  > which really allows it to be used as an OS API, which Rust can't do. I think that's a massive simplification
  - ninkendo 3y ago
    In what way? OS API’s can’t reasonably be copy/pasted into every binary on the system. It’s one thing to have large executables for third party apps you install, but you’d get tired of the wasted disk space really quickly if every binary in the OS had to statically link in the implementation of every library it used. It’s not just disk space either, but the ability for an OS as a platform to swap out implementations of their API’s with new ones, without requiring every app to be recompiled. It’s the reason macOS is able to implement things like dark mode, or a new UI theme, or any other “horizontal” feature that works across all apps; you need dynamic linking for that to be possible.
- duped 3y ago
  It worked for Microsoft VC++ for a long time.
  - pjmlp 3y ago
    Nowadays they rely on COM for that purpose, which is nice as idea, if the tooling wasn't so clunky.
    - duped 3y ago
      MSVC++ 2015 or later has a stable ABI independent of COM.
      - ninkendo 3y ago
        I’m interested in how this works (this thread is now getting old so I’m not sure there will be replies…) One of the important aspects of a stable ABI is the ability for clients to continue to work even after the size of a remote type changes… for instance, if Foo is a type defined in Foo.dll, and I link to it, and my code does `Foo *f = new Foo()`, the compiler will emit code that malloc’s `sizeof(Foo)` bytes on the heap. If later on, Foo gets a new member variable “m”, it will increase in size, and now code in Foo.dll will segfault if it tries to access `this->m`, if a client allocated it. COM solves this by basically not letting you do `new Foo`, but instead you have to ask COM itself to allocate and return an instance for you, with something like `CoCreateInstance`. This allows .dll’s to evolve even if the size of the object changes, by abstracting away things like size information so that clients don’t care about it. ObjC solves this similarly with `[SomeClass alloc]`, where clients just ask the class to alloc itself and returns a pointer (which is delayed until runtime, not in the emitted code), and Swift solves it with value witness tables which delay the lookup of size/stride information until runtime. I don’t understand how, you can write .dll’s with not only a stable ABI, but the ability to actually evolve your types, in plain vanilla C++… I think the language itself has painted itself into a corner that prevents things like this.
        pjmlp 3y ago
        Yes, hence one of the reasons why WinRT came to be, as COM evolution. You get .NET metadata, IInspectable, and an improved type system, basically .NET CLS. It doesn't expose everything C++ can do, but enough C with classes, OOP ABI and generics. https://learn.microsoft.com/en-us/uwp/winrt-cref/winmd-files https://learn.microsoft.com/en-us/uwp/winrt-cref/winmd-files Basically what COM vNext was going to be, if it wasn't for .NET pivot (see Ext-VOS). However the tooling is as clunky as using ATL.
      - pjmlp 3y ago
- dcow 3y ago
  I read Graydon's recent "If I were a BDFI" essay and found myself mostly sympathizing, especially with the "I wanted Rust to have potentially costly abstractions, because that's the point of abstractions, pay a known cost to solve common problems". It seems Rust was taken over by the "zero cost abstractions at all costs" crowd. Graydon seems at peace with that because it's what the community wanted. But I think it's also obvious that he was frustrated by the regression to the mean that comes with shared ownership/leadership. Then I thought that what we really need is a Swift-like language with the ability to remove costly abstractions when you don't want to pay the cost, but that default to ergonomically solving the problems that the majority of programs need to solve. You should opt-in to more semantic complexity, not be encumbered by it by default. Rust's obsession with performance above all else confuses me. But I also guess it's nice to have a safe space for performance sensitive programmers. But like how can a systems language not have a stable ABI? Very mixed messages. Ultimately this "Rust with better ergonomics" language could be Swift. I do think it is more usable across platforms than people give it credit for. But it's also missing the "let me dip down into lower level but more complicated semantics when I need to" option. Having a stable ABI is awesome, though. I really can't wait for the day where I can start a portable project in Swift without a second thought.
  - AceJohnny2 3y ago
    > Rust's obsession with performance above all else confuses me. It's kind of a requirement if they hope to replace C/C++ as a systems language, as those remain the goto answer for "I need maximum control", short of assembly. And they want to replace C/C++ to fix all their safety problems. I work in embedded systems, where C remains a holdout, with all its problems. Rust's performance-oriented direction makes it a viable consideration for us.
    - dcow 3y ago
      I understand the need to compete with C/C++. My understanding of zero cost abstractions is that they predominantly happen at compile time (and thus commonly appear in language semantics or the type system) and literally cost nothing at runtime. This has other costs like semantic complexity, but almost never performance. Regardless, I don't buy that Rust couldn’t present a more opinionated and complete programming experience without allowing the same performance characteristics that it has today. The whole async situation is awful. Lifetimes are a stupid leaky abstraction 99% of the time. My point is that there’s almost never a scenario where you e.g. need to bother with passing around a struct with a reference with a lifetime. 99% of the time you just take ownership of the data or use an Arc<Box<T>> and 99% of the time that’s not a performance problem. What I think is stupid is that Rust elevates and enshrines the 1% use cases and makes the 99% experience worse off for it. I love Rust. But it could do a better job of solving the 99% cases nicely while allowing a “zero cost escape hatch” where you could say “actually I do want a stack allocated reference without atomic reference counting” and pay the semantic price 1% of the time rather than 99% of the time, similar to Swift’s approach. Obviously my experience had been shaped by the projects I’ve worked on. But I also think Swift is an entirely more ergonomic and practical language. If you think Rust is a viable option then, unless you’re anti-Apple, Swift with ownership semantics most certainly is too. Seriously.
heavyset_go 3y ago
Not if you're using anything other than macOS or iOS derived systems.
- wahnfrieden 3y ago
  What? Huh? You forgot Windows, Linux, WASM in browser, WASI envs
  - heavyset_go 3y ago
    Swift is next to useless on any platform other than Apple's.
    - wahnfrieden 3y ago
      [flagged]
      - Larrikin 3y ago
        Swift is most comparable to Kotlin in the current crop of languages and the Kotlin team is doing their best to get multiplatform, backend, KotlinJS, and native everywhere. Kotlin dominates Android obviously, but is growing quickly on the backend. The other implementations are still early but they continue to be improved. I don't see Swift anywhere outside of Apple and don't see why anyone would reach for it instead of Kotlin. It also doesn't help that JetBrains has an IDE that makes development in the language so nice people are willing to pay for it and Xcode easily is the worst user experience of any current product developed by Apple.
        lockhouse 3y ago
        I see people claim this frequently that Kotlin is used a lot on the backend, but there’s very little evidence that this is true. I absolutely will concede that Swift is in practice an Apple only language, but I feel Kotlin is essentially an Android only language in practice as well.
rychco 3y ago
I’ve been interested in Swift for a while, but have no MacOS devices. What’s the status of swift on Windows/Linux?
- kitsunesoba 3y ago
  It's not as good as Xcode, but you can set up a serviceable Swift dev environment on Linux with VS Code and the official Swift VS Code plugin which adds LSP and debugger support. It's easiest to set up in Ubuntu and Fedora but should be possible in in other distros. I haven't toyed with Swift under Windows, but the devs behind Arc Browser have been hiring people to work on improving Windows tooling and writing a Swift wrapper for WinUI 3.
- ii41 3y ago
  Unusable. People seem to be concerned about Rust's ecosystem dying, but Swift's ecosystem is essentially Apple's system built-in libs + a handful of good open source packages. You need to do everything yourself when Apple's sys libs are not accessible.
  - myko 3y ago
    It is frustrating that Combine and SwiftUI were not open sourced, though there are few other Apple packages I find I want to reach for on Linux
    - jurip 3y ago
      With this year's WWDC announcements, it seems more obvious than ever that Combine was a bridge technology that has served its purpose now that Swift concurrency is taking over, and those things are open source. Doesn't help with SwiftUI, but just open sourcing it wouldn't have helped much that much without also having platform bindings, given that it uses UIKit on iOS and AppKit on Mac.
      - myko 3y ago
        That's true, Combine is a dead technology. Frustrating as I prefer it in a lot of cases to Swift concurrency, but I've been an Rx fan for a decade or so.
ii41 3y ago
The quality of implementation of the Swift compiler is in no way comparable to Rust's. It's super easy to cause its type check to timeout, which is something I haven't seen when using Rust. I even managed to make it crash several times. It also lacks some pretty standard features such as turning off warnings of a certain type or on a certain line. The language itself is quite problematic when compared to Rust, too. For instance, Swift doesn't have the orphan rule, so it's possible that 2 packages implement the same protocol for the same type, and when this happens currently there are no solutions; there is this strange design decision that classes and structs should be different things and each have their own set of random limitations; and there is SwiftUI, which hacks on the syntax itself, making statements no longer mean what they are supposed to mean.
- slavapestov 3y ago
  > It's super easy to cause its type check to timeout, which is something I haven't seen when using Rust. Yeah, the operator overloading design makes it too easy to construct an exponential search space. > For instance, Swift doesn't have the orphan rule, so it's possible that 2 packages implement the same protocol for the same type, and when this happens currently there are no solutions; There's now a warning about this: https://github.com/apple/swift-evolution/blob/main/proposals/0364-retroactive-conformance-warning.md https://github.com/apple/swift-evolution/blob/main/proposals.... What other solutions can there be other than making it a hard error? It seems like an inherent drawback of typeclasses over first-class modules. > there is this strange design decision that classes and structs should be different things and each have their own set of random limitations structs in Swift are the same as structs in Rust, and a class is a heap-allocated reference counted box, like an Arc<Box<T>>. What are the random limitations? As far as I'm aware the behavioral differences between structs and classes are entirely explainable by the above. > and there is SwiftUI, which hacks on the syntax itself, making statements no longer mean what they are supposed to mean Result builders are a language feature and not part of SwiftUI: https://github.com/apple/swift-evolution/blob/main/proposals/0289-result-builders.md https://github.com/apple/swift-evolution/blob/main/proposals...
  - ii41 3y ago
biorach 3y ago
> Rust kicks the bucket, Sorry, what?
- crazygringo 3y ago
  https://en.wikipedia.org/wiki/Kick_the_bucket https://en.wikipedia.org/wiki/Kick_the_bucket
perardi 3y ago
Having seen a few references on here to Rust kicking the bucket…is that a risk with Rust? This is a good-faith, non-trolling question. Rust is way out of my wheelhouse, but it’s obviously gained enough momentum that even I’m aware of it. Is there some language or community issue?
- Tuna-Fish 3y ago
  No. There is a lot of drama in the project leadership (and has been since the beginning), but that's mostly irrelevant to people just using the language. This latest flareup is about a conference keynote speaker, not something relevant to the language itself. If the project becomes dysfunctional enough, it can always be forked, as it is fully OSS.
- slavapestov 3y ago
  > Having seen a few references on here to Rust kicking the bucket…is that a risk with Rust? IMO Rust is long past the point (in terms of real world usage, commercial backing, etc) where it might “kick the bucket”.
- lukevp 3y ago
  As a rust mostly-outsider, I saw some recent drama (of the interpersonal kind) related to some unilateral action taken by a member of the rust team without a consensus, to downgrade someone’s conference talk, but I haven’t heard of anything that fundamentally impacts the language today. If they alienate their community, maybe in the long term there may be issues, but I certainly don’t make language decisions based on drama in the community. I may have easily misread this though, and would be happy to hear if it’s something bigger than it seemed to me.
- Georgelemental 3y ago
  The project had had a string of governance issues recently. The old leadership structure fell apart (2 years ago) due to irreconcilable disagreements. Then the informal temporary replacement governance, due to a sequence of miscommunications and process failures, committed a major slight against a prominent C community member who had been scheduled to speak at a Rust conference (1 week ago). Said temporary governance system is currently (as in, should be done in 1-2 days max) being replaced by the new permanent governance council, which will hopefully improve things. In any case, Rust is unlikely to fail because it is the only viable option in its niche (safe systems programming language that can replace C++ everywhere), and has gotten a large amount of investment from major corporations.
ergeysay 3y ago
At this point Haxe or Zig would be far better candidates, but this depends on why Rust was chosen in the first place.
rvcdbn 3y ago
What would it take to make it plan A? My take: rust-level WASM support and a decent standard library.

I find it very notable that Graydon Hoare, the "founder" of Rust, went on to work at Apple on Swift for a while. Also, Swift had tremendous work to implement ABI stability[1], which really allows it to be used as an OS API, which Rust can't do. [1] https://faultlore.com/blah/swift-abi/ https://faultlore.com/blah/swift-abi/

biorach 3y ago
> which really allows it to be used as an OS API, which Rust can't do. I think that's a massive simplification
- ninkendo 3y ago
  In what way? OS API’s can’t reasonably be copy/pasted into every binary on the system. It’s one thing to have large executables for third party apps you install, but you’d get tired of the wasted disk space really quickly if every binary in the OS had to statically link in the implementation of every library it used. It’s not just disk space either, but the ability for an OS as a platform to swap out implementations of their API’s with new ones, without requiring every app to be recompiled. It’s the reason macOS is able to implement things like dark mode, or a new UI theme, or any other “horizontal” feature that works across all apps; you need dynamic linking for that to be possible.
duped 3y ago
It worked for Microsoft VC++ for a long time.
- pjmlp 3y ago
  Nowadays they rely on COM for that purpose, which is nice as idea, if the tooling wasn't so clunky.
  - duped 3y ago
    MSVC++ 2015 or later has a stable ABI independent of COM.
    - ninkendo 3y ago
      I’m interested in how this works (this thread is now getting old so I’m not sure there will be replies…) One of the important aspects of a stable ABI is the ability for clients to continue to work even after the size of a remote type changes… for instance, if Foo is a type defined in Foo.dll, and I link to it, and my code does `Foo *f = new Foo()`, the compiler will emit code that malloc’s `sizeof(Foo)` bytes on the heap. If later on, Foo gets a new member variable “m”, it will increase in size, and now code in Foo.dll will segfault if it tries to access `this->m`, if a client allocated it. COM solves this by basically not letting you do `new Foo`, but instead you have to ask COM itself to allocate and return an instance for you, with something like `CoCreateInstance`. This allows .dll’s to evolve even if the size of the object changes, by abstracting away things like size information so that clients don’t care about it. ObjC solves this similarly with `[SomeClass alloc]`, where clients just ask the class to alloc itself and returns a pointer (which is delayed until runtime, not in the emitted code), and Swift solves it with value witness tables which delay the lookup of size/stride information until runtime. I don’t understand how, you can write .dll’s with not only a stable ABI, but the ability to actually evolve your types, in plain vanilla C++… I think the language itself has painted itself into a corner that prevents things like this.
      - pjmlp 3y ago
        Yes, hence one of the reasons why WinRT came to be, as COM evolution. You get .NET metadata, IInspectable, and an improved type system, basically .NET CLS. It doesn't expose everything C++ can do, but enough C with classes, OOP ABI and generics. https://learn.microsoft.com/en-us/uwp/winrt-cref/winmd-files https://learn.microsoft.com/en-us/uwp/winrt-cref/winmd-files Basically what COM vNext was going to be, if it wasn't for .NET pivot (see Ext-VOS). However the tooling is as clunky as using ATL.
    - pjmlp 3y ago
dcow 3y ago
I read Graydon's recent "If I were a BDFI" essay and found myself mostly sympathizing, especially with the "I wanted Rust to have potentially costly abstractions, because that's the point of abstractions, pay a known cost to solve common problems". It seems Rust was taken over by the "zero cost abstractions at all costs" crowd. Graydon seems at peace with that because it's what the community wanted. But I think it's also obvious that he was frustrated by the regression to the mean that comes with shared ownership/leadership. Then I thought that what we really need is a Swift-like language with the ability to remove costly abstractions when you don't want to pay the cost, but that default to ergonomically solving the problems that the majority of programs need to solve. You should opt-in to more semantic complexity, not be encumbered by it by default. Rust's obsession with performance above all else confuses me. But I also guess it's nice to have a safe space for performance sensitive programmers. But like how can a systems language not have a stable ABI? Very mixed messages. Ultimately this "Rust with better ergonomics" language could be Swift. I do think it is more usable across platforms than people give it credit for. But it's also missing the "let me dip down into lower level but more complicated semantics when I need to" option. Having a stable ABI is awesome, though. I really can't wait for the day where I can start a portable project in Swift without a second thought.
- AceJohnny2 3y ago
  > Rust's obsession with performance above all else confuses me. It's kind of a requirement if they hope to replace C/C++ as a systems language, as those remain the goto answer for "I need maximum control", short of assembly. And they want to replace C/C++ to fix all their safety problems. I work in embedded systems, where C remains a holdout, with all its problems. Rust's performance-oriented direction makes it a viable consideration for us.
  - dcow 3y ago
    I understand the need to compete with C/C++. My understanding of zero cost abstractions is that they predominantly happen at compile time (and thus commonly appear in language semantics or the type system) and literally cost nothing at runtime. This has other costs like semantic complexity, but almost never performance. Regardless, I don't buy that Rust couldn’t present a more opinionated and complete programming experience without allowing the same performance characteristics that it has today. The whole async situation is awful. Lifetimes are a stupid leaky abstraction 99% of the time. My point is that there’s almost never a scenario where you e.g. need to bother with passing around a struct with a reference with a lifetime. 99% of the time you just take ownership of the data or use an Arc<Box<T>> and 99% of the time that’s not a performance problem. What I think is stupid is that Rust elevates and enshrines the 1% use cases and makes the 99% experience worse off for it. I love Rust. But it could do a better job of solving the 99% cases nicely while allowing a “zero cost escape hatch” where you could say “actually I do want a stack allocated reference without atomic reference counting” and pay the semantic price 1% of the time rather than 99% of the time, similar to Swift’s approach. Obviously my experience had been shaped by the projects I’ve worked on. But I also think Swift is an entirely more ergonomic and practical language. If you think Rust is a viable option then, unless you’re anti-Apple, Swift with ownership semantics most certainly is too. Seriously.

heavyset_go 3y ago

Not if you're using anything other than macOS or iOS derived systems.

wahnfrieden 3y ago
What? Huh? You forgot Windows, Linux, WASM in browser, WASI envs
- heavyset_go 3y ago
  Swift is next to useless on any platform other than Apple's.
  - wahnfrieden 3y ago
    [flagged]
    - Larrikin 3y ago
      Swift is most comparable to Kotlin in the current crop of languages and the Kotlin team is doing their best to get multiplatform, backend, KotlinJS, and native everywhere. Kotlin dominates Android obviously, but is growing quickly on the backend. The other implementations are still early but they continue to be improved. I don't see Swift anywhere outside of Apple and don't see why anyone would reach for it instead of Kotlin. It also doesn't help that JetBrains has an IDE that makes development in the language so nice people are willing to pay for it and Xcode easily is the worst user experience of any current product developed by Apple.
      - lockhouse 3y ago
        I see people claim this frequently that Kotlin is used a lot on the backend, but there’s very little evidence that this is true. I absolutely will concede that Swift is in practice an Apple only language, but I feel Kotlin is essentially an Android only language in practice as well.

rychco 3y ago

I’ve been interested in Swift for a while, but have no MacOS devices. What’s the status of swift on Windows/Linux?

kitsunesoba 3y ago
It's not as good as Xcode, but you can set up a serviceable Swift dev environment on Linux with VS Code and the official Swift VS Code plugin which adds LSP and debugger support. It's easiest to set up in Ubuntu and Fedora but should be possible in in other distros. I haven't toyed with Swift under Windows, but the devs behind Arc Browser have been hiring people to work on improving Windows tooling and writing a Swift wrapper for WinUI 3.
ii41 3y ago
Unusable. People seem to be concerned about Rust's ecosystem dying, but Swift's ecosystem is essentially Apple's system built-in libs + a handful of good open source packages. You need to do everything yourself when Apple's sys libs are not accessible.
- myko 3y ago
  It is frustrating that Combine and SwiftUI were not open sourced, though there are few other Apple packages I find I want to reach for on Linux
  - jurip 3y ago
    With this year's WWDC announcements, it seems more obvious than ever that Combine was a bridge technology that has served its purpose now that Swift concurrency is taking over, and those things are open source. Doesn't help with SwiftUI, but just open sourcing it wouldn't have helped much that much without also having platform bindings, given that it uses UIKit on iOS and AppKit on Mac.
    - myko 3y ago
      That's true, Combine is a dead technology. Frustrating as I prefer it in a lot of cases to Swift concurrency, but I've been an Rx fan for a decade or so.

ii41 3y ago

The quality of implementation of the Swift compiler is in no way comparable to Rust's. It's super easy to cause its type check to timeout, which is something I haven't seen when using Rust. I even managed to make it crash several times. It also lacks some pretty standard features such as turning off warnings of a certain type or on a certain line. The language itself is quite problematic when compared to Rust, too. For instance, Swift doesn't have the orphan rule, so it's possible that 2 packages implement the same protocol for the same type, and when this happens currently there are no solutions; there is this strange design decision that classes and structs should be different things and each have their own set of random limitations; and there is SwiftUI, which hacks on the syntax itself, making statements no longer mean what they are supposed to mean.

slavapestov 3y ago
> It's super easy to cause its type check to timeout, which is something I haven't seen when using Rust. Yeah, the operator overloading design makes it too easy to construct an exponential search space. > For instance, Swift doesn't have the orphan rule, so it's possible that 2 packages implement the same protocol for the same type, and when this happens currently there are no solutions; There's now a warning about this: https://github.com/apple/swift-evolution/blob/main/proposals/0364-retroactive-conformance-warning.md https://github.com/apple/swift-evolution/blob/main/proposals.... What other solutions can there be other than making it a hard error? It seems like an inherent drawback of typeclasses over first-class modules. > there is this strange design decision that classes and structs should be different things and each have their own set of random limitations structs in Swift are the same as structs in Rust, and a class is a heap-allocated reference counted box, like an Arc<Box<T>>. What are the random limitations? As far as I'm aware the behavioral differences between structs and classes are entirely explainable by the above. > and there is SwiftUI, which hacks on the syntax itself, making statements no longer mean what they are supposed to mean Result builders are a language feature and not part of SwiftUI: https://github.com/apple/swift-evolution/blob/main/proposals/0289-result-builders.md https://github.com/apple/swift-evolution/blob/main/proposals...
- ii41 3y ago

biorach 3y ago

> Rust kicks the bucket, Sorry, what?

crazygringo 3y ago
https://en.wikipedia.org/wiki/Kick_the_bucket https://en.wikipedia.org/wiki/Kick_the_bucket

perardi 3y ago

Having seen a few references on here to Rust kicking the bucket…is that a risk with Rust? This is a good-faith, non-trolling question. Rust is way out of my wheelhouse, but it’s obviously gained enough momentum that even I’m aware of it. Is there some language or community issue?

Tuna-Fish 3y ago
No. There is a lot of drama in the project leadership (and has been since the beginning), but that's mostly irrelevant to people just using the language. This latest flareup is about a conference keynote speaker, not something relevant to the language itself. If the project becomes dysfunctional enough, it can always be forked, as it is fully OSS.
slavapestov 3y ago
> Having seen a few references on here to Rust kicking the bucket…is that a risk with Rust? IMO Rust is long past the point (in terms of real world usage, commercial backing, etc) where it might “kick the bucket”.
lukevp 3y ago
As a rust mostly-outsider, I saw some recent drama (of the interpersonal kind) related to some unilateral action taken by a member of the rust team without a consensus, to downgrade someone’s conference talk, but I haven’t heard of anything that fundamentally impacts the language today. If they alienate their community, maybe in the long term there may be issues, but I certainly don’t make language decisions based on drama in the community. I may have easily misread this though, and would be happy to hear if it’s something bigger than it seemed to me.
Georgelemental 3y ago
The project had had a string of governance issues recently. The old leadership structure fell apart (2 years ago) due to irreconcilable disagreements. Then the informal temporary replacement governance, due to a sequence of miscommunications and process failures, committed a major slight against a prominent C community member who had been scheduled to speak at a Rust conference (1 week ago). Said temporary governance system is currently (as in, should be done in 1-2 days max) being replaced by the new permanent governance council, which will hopefully improve things. In any case, Rust is unlikely to fail because it is the only viable option in its niche (safe systems programming language that can replace C++ everywhere), and has gotten a large amount of investment from major corporations.

ergeysay 3y ago

At this point Haxe or Zig would be far better candidates, but this depends on why Rust was chosen in the first place.

rvcdbn 3y ago

What would it take to make it plan A? My take: rust-level WASM support and a decent standard library.